pyftdb.c

#include "pyftdb.h"

#include <stdbool.h>
#include <pthread.h>
#include "uflat.h"

#define FTDB_MODULE_INIT_CHECK  \
    do {    \
        if (!__self->init_done) {   \
            PyErr_SetString(libftdb_ftdbError, "Core 'ftdb' module not initialized. Please use 'ftdb = libftdb.ftdb()' or similar.");   \
            return 0;   \
        }   \
    } while(0)

struct ftdb_ref {
    const struct ftdb* ftdb;
    unsigned long refcount;
};

pthread_mutex_t unflatten_lock = PTHREAD_MUTEX_INITIALIZER;
struct rb_root ftdb_image_map;

static const char* PyString_get_c_str(PyObject* s) {

    if (PyUnicode_Check(s)) {
        PyObject* us = PyUnicode_AsUTF8String(s);
        if (us) {
            return PyBytes_AsString(us);
        }
        else {
            return 0;
        }
    }
    else {
        return (const char*)0xdeadbeef;
    }
}

PyObject* libftdb_generic_richcompare(PyObject *self, PyObject *other, int op) {
    if(op != Py_EQ && op != Py_NE)
        Py_RETURN_NOTIMPLEMENTED;
    if(self == other)
        Py_RETURN_TRUE;

    if (Py_TYPE(self) != Py_TYPE(other))
        Py_RETURN_NOTIMPLEMENTED;
    
    PyObject* self_json = PyObject_CallMethod(self, "json", "");
    PyObject* other_json = PyObject_CallMethod(other, "json", "");
    bool compare = PyObject_RichCompareBool(self_json, other_json, op);
    Py_DECREF(self_json);
    Py_DECREF(other_json);

    if(compare) 
        Py_RETURN_TRUE;
    Py_RETURN_FALSE;
}

PyObject *libftdb_ftdbError;

void libftdb_ftdb_dealloc(libftdb_ftdb_object* self) {

    PyTypeObject *tp = Py_TYPE(self);
    if (self->init_done) {
        int mutex_err = pthread_mutex_lock(&unflatten_lock);
        if (mutex_err) {
            printf("libftdb_ftdb_dealloc(): failed to lock mutex - %d\n",mutex_err);
        }
        else {
            struct ftdb_ref* ftdb_ref = (struct ftdb_ref*)self->ftdb_image_map_node->value;
            if (--ftdb_ref->refcount==0) {
                /* No more ftdb objects are holding this image file */
                stringRefMap_remove(&ftdb_image_map,self->ftdb_image_map_node);
                free((void*)self->ftdb_image_map_node->value);
                free((void*)self->ftdb_image_map_node);
                unflatten_deinit(self->unflatten);
            }
            pthread_mutex_unlock(&unflatten_lock);
        }
    }
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    libftdb_ftdb_object* self;

    self = (libftdb_ftdb_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        /* Use the 'load' function (or constructor) to initialize the cache */
        self->init_done = 0;
        self->ftdb = 0;
    }

    return (PyObject *)self;
}

int libftdb_ftdb_init(libftdb_ftdb_object* self, PyObject* args, PyObject* kwds) {

    if (PyTuple_Size(args)>0) {
        (void)libftdb_ftdb_load(self,args,kwds);
    }

    return 0;
}

PyObject* libftdb_ftdb_repr(PyObject* self) {

    static char repr[1024];

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    const char* inited = "initialized";
    const char* ninited = "not initialized";
    int written = snprintf(repr,1024,"<ftdb object at %lx : %s",(uintptr_t)self,__self->init_done?inited:ninited);
        if (__self->init_done) {
            written+=snprintf(repr+written,1024-written,"|debug:%d;verbose:%d|",__self->debug,__self->verbose);
        written+=snprintf(repr+written,1024-written,"funcs_count:%lu;types_count:%lu;global_count:%lu;sources:%lu>",
            __self->ftdb->funcs_count,__self->ftdb->types_count,
            __self->ftdb->globals_count,__self->ftdb->sourceindex_table_count);
        }
        else {
            written+=snprintf(repr+written,1024-written,">");
        }


    return PyUnicode_FromString(repr);
}

int libftdb_ftdb_bool(PyObject* self) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    return __self->init_done;
}

PyObject* libftdb_ftdb_load(libftdb_ftdb_object* self, PyObject* args, PyObject* kwargs ) {

    static char* kwlist[] = {"filename", "quiet", "debug", NULL};
    const char* cache_filename = "db.img";
    int debug = self->debug;
    int quiet = 0;
    bool err = true;

    if(!PyArg_ParseTupleAndKeywords(args, kwargs, "|s$pp", kwlist,
        &cache_filename, &quiet, &debug))
        return NULL;	/* Exception is already set by PyArg_ParseTupleAndKeywords */


    DBG( debug, "--- libftdb_ftdb_load(\"%s\")\n",cache_filename);

    if (self->init_done) {
        PyErr_SetString(libftdb_ftdbError, "ftdb cache already initialized");
        goto done;
    }

    int mutex_err = pthread_mutex_lock(&unflatten_lock);
    if (mutex_err) {
        printf("libftdb_ftdb_load(): failed to lock mutex - %d\n",mutex_err);
        PyErr_SetString(libftdb_ftdbError, "Loading ftdb cache failed");
        goto done;
    }

    struct stringRefMap_node* node = stringRefMap_search(&ftdb_image_map, cache_filename);
    if (node) {
        /* The cache database for the requested filename is already present and loaded into the process memory */
        self->ftdb = (const struct ftdb*)((struct ftdb_ref*)node->value)->ftdb;
        self->ftdb_image_map_node = node;
        ((struct ftdb_ref*)node->value)->refcount++;
        DBG( true, "Re-used loaded input file\n");
    }
    else {

        /* Try to load new cache database file */
        FILE* in = fopen(cache_filename, "r+b");
        if(!in) {
            in = fopen(cache_filename, "rb");
            if(!in) {
                PyErr_Format(libftdb_ftdbError, "Cannot open cache file - (%d) %s", errno, strerror(errno));
                goto done;
            }
        }

        int debug_level = 0;
        if(debug) debug_level = 2;
        else if(!quiet) debug_level = 1;

        self->unflatten = unflatten_init(debug_level);
        if(self->unflatten == NULL) {
            PyErr_SetString(libftdb_ftdbError, "Failed to intialize unflatten library");
            goto done;
        }

        if (unflatten_load_continuous(self->unflatten, in, NULL)) {
            PyErr_SetString(libftdb_ftdbError, "Failed to read cache file");
            unflatten_deinit(self->unflatten);
            goto done;
        }
        fclose(in);

        self->ftdb = (const struct ftdb*) unflatten_root_pointer_next(self->unflatten);

        /* Check whether it's correct file and in supported version */
        if(self->ftdb->db_magic != FTDB_MAGIC_NUMBER) {
            PyErr_Format(libftdb_ftdbError, "Failed to parse cache file - invalid magic %p", self->ftdb->db_magic);
            unflatten_deinit(self->unflatten);
            goto done;
        }
        if(self->ftdb->db_version != FTDB_VERSION) {
            PyErr_Format(libftdb_ftdbError, "Failed to parse cache file - unsupported image version %p (required: %p)", self->ftdb->db_version, FTDB_VERSION);
            unflatten_deinit(self->unflatten);
            goto done;
        }

        struct ftdb_ref* ftdb_ref = malloc(sizeof(struct ftdb_ref));
        ftdb_ref->ftdb = self->ftdb;
        ftdb_ref->refcount = 1;
        self->ftdb_image_map_node = stringRefMap_insert(&ftdb_image_map, cache_filename, (unsigned long)ftdb_ref);
    }

    self->init_done = 1;
    err = false;

done:
    pthread_mutex_unlock(&unflatten_lock);
    if (err) {
        self->ftdb = self->unflatten = NULL;
        return NULL;	/* Indicate that exception has been set */
    }
    Py_RETURN_TRUE;
}

PyObject* libftdb_ftdb_get_refcount(PyObject* self, void* closure) {
    return PyLong_FromLong(self->ob_refcnt);
}

PyObject* libftdb_ftdb_get_version(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    return PyUnicode_FromString(__self->ftdb->version);
}

PyObject* libftdb_ftdb_get_module(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    return PyUnicode_FromString(__self->ftdb->module);
}

PyObject* libftdb_ftdb_get_directory(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    return PyUnicode_FromString(__self->ftdb->directory);
}

PyObject* libftdb_ftdb_get_release(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    return PyUnicode_FromString(__self->ftdb->release);
}

PyObject* libftdb_ftdb_get_sources(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    PyObject* args = PyTuple_New(2);
    PyTuple_SetItem(args,0,PyLong_FromLong((uintptr_t)__self->ftdb));
    PYTUPLE_SET_ULONG(args,1,(uintptr_t)self);
    PyObject *sources = PyObject_CallObject((PyObject *) &libftdb_ftdbSourcesType, args);
    Py_DECREF(args);
    return sources;
}

PyObject* libftdb_ftdb_get_sources_as_dict(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    PyObject* sources = PyList_New(0);
    for (unsigned long i=0; i<__self->ftdb->sourceindex_table_count; ++i) {
        PyObject* py_sources_entry = PyDict_New();
        FTDB_SET_ENTRY_ULONG(py_sources_entry,id,i);
        FTDB_SET_ENTRY_STRING(py_sources_entry,name,__self->ftdb->sourceindex_table[i]);
        PyList_Append(sources,py_sources_entry);
        Py_DecRef(py_sources_entry);
    }
    return sources;
}

PyObject* libftdb_ftdb_get_sources_as_list(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;

    PyObject* sources = PyList_New(0);
    for (unsigned long i=0; i<__self->ftdb->sourceindex_table_count; ++i) {
        PyObject* py_sources_entry = PyDict_New();
        PyObject* key = PyUnicode_FromString(__self->ftdb->sourceindex_table[i]);
        PyObject* val = PyLong_FromUnsignedLong(i);
        PyDict_SetItem(py_sources_entry,key,val);
        Py_DecRef(key);
        Py_DecRef(val);
        PyList_Append(sources,py_sources_entry);
        Py_DecRef(py_sources_entry);
    }
    return sources;
}

PyObject* libftdb_ftdb_get_modules(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    PyObject* args = PyTuple_New(2);
    PyTuple_SetItem(args,0,PyLong_FromLong((uintptr_t)__self->ftdb));
    PYTUPLE_SET_ULONG(args,1,(uintptr_t)self);
    PyObject *modules = PyObject_CallObject((PyObject *) &libftdb_ftdbModulesType, args);
    Py_DECREF(args);
    return modules;
}

PyObject* libftdb_ftdb_get_modules_as_dict(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    PyObject* modules = PyList_New(0);
    for (unsigned long i=0; i<__self->ftdb->moduleindex_table_count; ++i) {
        PyObject* py_modules_entry = PyDict_New();
        FTDB_SET_ENTRY_ULONG(py_modules_entry,id,i);
        FTDB_SET_ENTRY_STRING(py_modules_entry,name,__self->ftdb->moduleindex_table[i]);
        PyList_Append(modules,py_modules_entry);
        Py_DecRef(py_modules_entry);
    }
    return modules;
}

PyObject* libftdb_ftdb_get_modules_as_list(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;

    PyObject* modules = PyList_New(0);
    for (unsigned long i=0; i<__self->ftdb->moduleindex_table_count; ++i) {
        PyObject* py_modules_entry = PyDict_New();
        PyObject* key = PyUnicode_FromString(__self->ftdb->moduleindex_table[i]);
        PyObject* val = PyLong_FromUnsignedLong(i);
        PyDict_SetItem(py_modules_entry,key,val);
        Py_DecRef(key);
        Py_DecRef(val);
        PyList_Append(modules,py_modules_entry);
        Py_DecRef(py_modules_entry);
    }
    return modules;
}

PyObject* libftdb_ftdb_get_funcs(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self->ftdb);
    PYTUPLE_SET_ULONG(args,1,(uintptr_t)self);
    PyObject *funcs = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncsType, args);
    Py_DECREF(args);
    return funcs;
}

PyObject* libftdb_ftdb_get_funcdecls(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self->ftdb);
    PYTUPLE_SET_ULONG(args,1,(uintptr_t)self);
    PyObject *funcdecls = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncdeclsType, args);
    Py_DECREF(args);
    return funcdecls;
}

PyObject* libftdb_ftdb_get_unresolvedfuncs(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self->ftdb);
    PYTUPLE_SET_ULONG(args,1,(uintptr_t)self);
    PyObject *unresolvedfuncs = PyObject_CallObject((PyObject *) &libftdb_ftdbUnresolvedfuncsType, args);
    Py_DECREF(args);
    return unresolvedfuncs;
}

PyObject* libftdb_ftdb_get_unresolvedfuncs_as_list(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;

    PyObject* unresolvedfuncs = PyList_New(0);
    for (unsigned long i=0; i<__self->ftdb->unresolvedfuncs_count; ++i) {
        struct ftdb_unresolvedfunc_entry* entry = &__self->ftdb->unresolvedfuncs[i];
        PyObject* py_unresolvedfuncs_entry = PyDict_New();
        FTDB_SET_ENTRY_STRING(py_unresolvedfuncs_entry,name,entry->name);
        FTDB_SET_ENTRY_ULONG(py_unresolvedfuncs_entry,id,entry->id);
        PyList_Append(unresolvedfuncs,py_unresolvedfuncs_entry);
        Py_DECREF(py_unresolvedfuncs_entry);
    }
    return unresolvedfuncs;
}

PyObject* libftdb_ftdb_get_globals(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self->ftdb);
    PYTUPLE_SET_ULONG(args,1,(uintptr_t)self);
    PyObject *globals = PyObject_CallObject((PyObject *) &libftdb_ftdbGlobalsType, args);
    Py_DECREF(args);
    return globals;
}

PyObject* libftdb_ftdb_get_types(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self->ftdb);
    PYTUPLE_SET_ULONG(args,1,(uintptr_t)self);
    PyObject *types = PyObject_CallObject((PyObject *) &libftdb_ftdbTypesType, args);
    Py_DECREF(args);
    return types;
}

PyObject* libftdb_ftdb_get_fops(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self->ftdb);
    PYTUPLE_SET_ULONG(args,1,(uintptr_t)self);
    PyObject *fops = PyObject_CallObject((PyObject *) &libftdb_ftdbFopsType, args);
    Py_DECREF(args);
    return fops;
}

PyObject* libftdb_ftdb_get_matrix_data_as_dict(struct matrix_data* matrix_data) {

    PyObject* md = PyList_New(0);

    PyObject* data = PyDict_New();
    FTDB_SET_ENTRY_STRING(data,name,"data");
    FTDB_SET_ENTRY_ULONG_ARRAY(data,data,matrix_data->data);
    PyList_Append(md,data);
    Py_DecRef(data);
    PyObject* row_ind = PyDict_New();
    FTDB_SET_ENTRY_STRING(row_ind,name,"row_ind");
    FTDB_SET_ENTRY_ULONG_ARRAY(row_ind,data,matrix_data->row_ind);
    PyList_Append(md,row_ind);
    Py_DecRef(row_ind);
    PyObject* col_ind = PyDict_New();
    FTDB_SET_ENTRY_STRING(col_ind,name,"col_ind");
    FTDB_SET_ENTRY_ULONG_ARRAY(col_ind,data,matrix_data->col_ind);
    PyList_Append(md,col_ind);
    Py_DecRef(col_ind);
    PyObject* matrix_size = PyDict_New();
    FTDB_SET_ENTRY_STRING(matrix_size,name,"matrix_size");
    FTDB_SET_ENTRY_ULONG(matrix_size,data,matrix_data->matrix_size);
    PyList_Append(md,matrix_size);
    Py_DecRef(matrix_size);

    return md;
}

PyObject* libftdb_ftdb_get_funcs_tree_calls_no_asm(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    if (!__self->ftdb->funcs_tree_calls_no_asm) {
        Py_RETURN_NONE;
    }

    return libftdb_ftdb_get_matrix_data_as_dict(__self->ftdb->funcs_tree_calls_no_asm);
}

PyObject* libftdb_ftdb_get_funcs_tree_calls_no_known(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    if (!__self->ftdb->funcs_tree_calls_no_known) {
        Py_RETURN_NONE;
    }

    return libftdb_ftdb_get_matrix_data_as_dict(__self->ftdb->funcs_tree_calls_no_known);
}

PyObject* libftdb_ftdb_get_funcs_tree_calls_no_known_no_asm(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    if (!__self->ftdb->funcs_tree_calls_no_known_no_asm) {
        Py_RETURN_NONE;
    }

    return libftdb_ftdb_get_matrix_data_as_dict(__self->ftdb->funcs_tree_calls_no_known_no_asm);
}

PyObject* libftdb_ftdb_get_funcs_tree_func_calls(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    if (!__self->ftdb->funcs_tree_func_calls) {
        Py_RETURN_NONE;
    }

    return libftdb_ftdb_get_matrix_data_as_dict(__self->ftdb->funcs_tree_func_calls);
}

PyObject* libftdb_ftdb_get_funcs_tree_func_refs(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    if (!__self->ftdb->funcs_tree_func_refs) {
        Py_RETURN_NONE;
    }

    return libftdb_ftdb_get_matrix_data_as_dict(__self->ftdb->funcs_tree_func_refs);
}

PyObject* libftdb_ftdb_get_funcs_tree_funrefs_no_asm(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    if (!__self->ftdb->funcs_tree_funrefs_no_asm) {
        Py_RETURN_NONE;
    }

    return libftdb_ftdb_get_matrix_data_as_dict(__self->ftdb->funcs_tree_funrefs_no_asm);
}

PyObject* libftdb_ftdb_get_funcs_tree_funrefs_no_known(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    if (!__self->ftdb->funcs_tree_funrefs_no_known) {
        Py_RETURN_NONE;
    }

    return libftdb_ftdb_get_matrix_data_as_dict(__self->ftdb->funcs_tree_funrefs_no_known);
}

PyObject* libftdb_ftdb_get_funcs_tree_funrefs_no_known_no_asm(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    if (!__self->ftdb->funcs_tree_funrefs_no_known_no_asm) {
        Py_RETURN_NONE;
    }

    return libftdb_ftdb_get_matrix_data_as_dict(__self->ftdb->funcs_tree_funrefs_no_known_no_asm);
}

PyObject* libftdb_ftdb_get_globs_tree_globalrefs(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    if (!__self->ftdb->globs_tree_globalrefs) {
        Py_RETURN_NONE;
    }

    return libftdb_ftdb_get_matrix_data_as_dict(__self->ftdb->globs_tree_globalrefs);
}

PyObject* libftdb_ftdb_get_types_tree_refs(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    if (!__self->ftdb->types_tree_refs) {
        Py_RETURN_NONE;
    }

    return libftdb_ftdb_get_matrix_data_as_dict(__self->ftdb->types_tree_refs);
}

PyObject* libftdb_ftdb_get_types_tree_usedrefs(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    if (!__self->ftdb->types_tree_usedrefs) {
        Py_RETURN_NONE;
    }

    return libftdb_ftdb_get_matrix_data_as_dict(__self->ftdb->types_tree_usedrefs);
}

PyObject* libftdb_ftdb_get_static_funcs_map(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    if (!__self->ftdb->static_funcs_map) {
        Py_RETURN_NONE;
    }

    PyObject* sfm = PyList_New(0);

    for (Py_ssize_t i=0; i<__self->ftdb->static_funcs_map_count; ++i) {
        struct func_map_entry* entry = &__self->ftdb->static_funcs_map[i];
        PyObject* data = PyDict_New();
        FTDB_SET_ENTRY_ULONG(data,id,entry->id);
        FTDB_SET_ENTRY_ULONG_ARRAY(data,fids,entry->fids);
        PYLIST_ADD_PYOBJECT(sfm,data);
    }

    return sfm;
}

PyObject* libftdb_ftdb_get_single_item_init_data(struct init_data_item* item) {
    
    PyObject* py_item = PyDict_New();
    FTDB_SET_ENTRY_ULONG_OPTIONAL(py_item,id,item->id);
    FTDB_SET_ENTRY_STRING_ARRAY(py_item,name,item->name);
    FTDB_SET_ENTRY_ULONG_OPTIONAL(py_item,size,item->size);
    if (item->size_dep) {
        PyObject* py_size_dep = PyDict_New();
        FTDB_SET_ENTRY_ULONG(py_size_dep,id,item->size_dep->id);
        FTDB_SET_ENTRY_INT64(py_size_dep,add,item->size_dep->add);
        FTDB_SET_ENTRY_PYOBJECT(py_item,size_dep,py_size_dep);
    }
    FTDB_SET_ENTRY_STRING_OPTIONAL(py_item,nullterminated,item->nullterminated);
    FTDB_SET_ENTRY_STRING_OPTIONAL(py_item,tagged,item->tagged);
    FTDB_SET_ENTRY_STRING_OPTIONAL(py_item,fuzz,item->fuzz);
    FTDB_SET_ENTRY_STRING_OPTIONAL(py_item,pointer,item->pointer);
    FTDB_SET_ENTRY_INT64_OPTIONAL(py_item,max_value,item->max_value);
    FTDB_SET_ENTRY_INT64_OPTIONAL(py_item,min_value,item->min_value);
    FTDB_SET_ENTRY_INT64_OPTIONAL(py_item,value,item->value);
    FTDB_SET_ENTRY_STRING_OPTIONAL(py_item,user_name,item->user_name);
    FTDB_SET_ENTRY_STRING_OPTIONAL(py_item,protected,item->protected_var);
    FTDB_SET_ENTRY_STRING_ARRAY_OPTIONAL(py_item,value_dep,item->value_dep);
    FTDB_SET_ENTRY_ULONG_OPTIONAL(py_item,fuzz_offset,item->fuzz_offset);
    FTDB_SET_ENTRY_STRING_OPTIONAL(py_item,force_type,item->force_type);
    FTDB_SET_ENTRY_STRING_ARRAY_OPTIONAL(py_item,always_init,item->always_init);
    if (item->subitems) {
        PyObject* py_subitems = PyList_New(0);
        for (Py_ssize_t i=0; i<item->subitems_count; ++i) {
            struct init_data_item* subitem = &item->subitems[i];
            PyObject* py_subitem = libftdb_ftdb_get_single_item_init_data(subitem);
            PYLIST_ADD_PYOBJECT(py_subitems,py_subitem);
        }
        FTDB_SET_ENTRY_PYOBJECT(py_item,subitems,py_subitems);
    }

    return py_item;
}

PyObject* libftdb_ftdb_get_init_data(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    if (!__self->ftdb->init_data) {
        Py_RETURN_NONE;
    }

    PyObject* init_data = PyList_New(0);
    for (Py_ssize_t i=0; i<__self->ftdb->init_data_count; ++i) {
        struct init_data_entry* entry = &__self->ftdb->init_data[i];
        PyObject* py_init_data_entry = PyDict_New();
        FTDB_SET_ENTRY_STRING(py_init_data_entry,name,entry->name);
        FTDB_SET_ENTRY_ULONG_ARRAY_OPTIONAL(py_init_data_entry,order,entry->order);
        FTDB_SET_ENTRY_STRING(py_init_data_entry,interface,entry->interface);
        PyObject* py_items = PyList_New(0);
        for (Py_ssize_t j=0; j<entry->items_count; ++j) {
            struct init_data_item* item = &entry->items[j];
            PyObject* py_item = libftdb_ftdb_get_single_item_init_data(item);
            PYLIST_ADD_PYOBJECT(py_items,py_item);
        }
        FTDB_SET_ENTRY_PYOBJECT(py_init_data_entry,items,py_items);
        PYLIST_ADD_PYOBJECT(init_data,py_init_data_entry);
    }

    return init_data;
}

PyObject* libftdb_ftdb_get_known_data(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    if (!__self->ftdb->known_data) {
        Py_RETURN_NONE;
    }

    PyObject* py_known_data_container = PyList_New(0);
    PyObject* py_known_data = PyDict_New();
    FTDB_SET_ENTRY_STRING(py_known_data,version,__self->ftdb->known_data->version);
    FTDB_SET_ENTRY_ULONG_ARRAY(py_known_data,func_ids,__self->ftdb->known_data->func_ids);
    FTDB_SET_ENTRY_ULONG_ARRAY(py_known_data,builtin_ids,__self->ftdb->known_data->builtin_ids);
    FTDB_SET_ENTRY_ULONG_ARRAY(py_known_data,asm_ids,__self->ftdb->known_data->asm_ids);
    FTDB_SET_ENTRY_STRING_ARRAY(py_known_data,lib_funcs,__self->ftdb->known_data->lib_funcs);
    FTDB_SET_ENTRY_ULONG_ARRAY(py_known_data,lib_funcs_ids,__self->ftdb->known_data->lib_funcs_ids);
    FTDB_SET_ENTRY_ULONG_ARRAY(py_known_data,always_inc_funcs_ids,__self->ftdb->known_data->always_inc_funcs_ids);
    FTDB_SET_ENTRY_ULONG_ARRAY(py_known_data,replacement_ids,__self->ftdb->known_data->replacement_ids);
    PYLIST_ADD_PYOBJECT(py_known_data_container,py_known_data);

    return py_known_data_container;
}

PyObject* libftdb_ftdb_get_BAS(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    if (!__self->ftdb->BAS_data) {
        Py_RETURN_NONE;
    }

    PyObject* py_BAS = PyList_New(0);
    for (Py_ssize_t i=0; i<__self->ftdb->BAS_data_count; ++i) {
        struct BAS_item* entry = &__self->ftdb->BAS_data[i];
        PyObject* py_BAS_entry = PyDict_New();
        FTDB_SET_ENTRY_STRING(py_BAS_entry,loc,entry->loc);
        FTDB_SET_ENTRY_STRING_ARRAY(py_BAS_entry,entries,entry->entries);
        PYLIST_ADD_PYOBJECT(py_BAS,py_BAS_entry);
    }

    return py_BAS;
}

PyObject* libftdb_ftdb_get_func_fptrs(PyObject* self, void* closure) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    if (!__self->ftdb->func_fptrs_data) {
        Py_RETURN_NONE;
    }

    PyObject* py_func_fptrs = PyList_New(0);
    for (Py_ssize_t i=0; i<__self->ftdb->func_fptrs_data_count; ++i) {
        struct func_fptrs_item* entry = &__self->ftdb->func_fptrs_data[i];
        PyObject* py_func_fptrs_entry = PyDict_New();
        FTDB_SET_ENTRY_ULONG(py_func_fptrs_entry,_id,entry->id);
        PyObject* py_entries = PyList_New(0);
        for (Py_ssize_t j=0; j<entry->entries_count; ++j) {
            struct func_fptrs_entry* item = &entry->entries[j];
            PyObject* py_entry = PyTuple_New(2);
            PYTUPLE_SET_STR(py_entry,0,item->fname);
            PyObject* py_ids = PyList_New(0);
            for (Py_ssize_t k=0; k<item->ids_count; ++k) {
                PYLIST_ADD_ULONG(py_ids,item->ids[k]);
            }
            PYTUPLE_SET_PYOBJECT(py_entry,1,py_ids);
            PYLIST_ADD_PYOBJECT(py_entries,py_entry);
        }
        FTDB_SET_ENTRY_PYOBJECT(py_func_fptrs_entry,entries,py_entries);
        PYLIST_ADD_PYOBJECT(py_func_fptrs,py_func_fptrs_entry);
    }

    return py_func_fptrs;
}

PyObject* libftdb_ftdb_mp_subscript(PyObject* self, PyObject* slice) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    static char errmsg[ERRMSG_BUFFER_SIZE];

    FTDB_MODULE_INIT_CHECK;

    if (!PyUnicode_Check(slice)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in property mapping (not a str)");
        Py_RETURN_NONE;
    }

    const char* attr = PyString_get_c_str(slice);

    if (!strcmp(attr,"version")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_version(self,0);
    }
    else if (!strcmp(attr,"module")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_module(self,0);
    }
    else if (!strcmp(attr,"directory")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_directory(self,0);
    }
    else if (!strcmp(attr,"release")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_release(self,0);
    }
    else if (!strcmp(attr,"sources")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_sources_as_list(self,0);
    }
    else if (!strcmp(attr,"source_info")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_sources_as_dict(self,0);
    }
    else if (!strcmp(attr,"modules")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_modules_as_list(self,0);
    }
    else if (!strcmp(attr,"module_info")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_modules_as_dict(self,0);
    }
    else if (!strcmp(attr,"funcs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_funcs(self,0);
    }
    else if (!strcmp(attr,"funcdecls")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_funcdecls(self,0);
    }
    else if (!strcmp(attr,"unresolvedfuncs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_unresolvedfuncs_as_list(self,0);
    }
    else if (!strcmp(attr,"globals")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_globals(self,0);
    }
    else if (!strcmp(attr,"types")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_types(self,0);
    }
    else if (!strcmp(attr,"fops")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_fops(self,0);
    }
    else if (!strcmp(attr,"funcs_tree_calls_no_asm")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_funcs_tree_calls_no_asm(self,0);
    }
    else if (!strcmp(attr,"funcs_tree_calls_no_known")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_funcs_tree_calls_no_known(self,0);
    }
    else if (!strcmp(attr,"funcs_tree_calls_no_known_no_asm")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_funcs_tree_calls_no_known_no_asm(self,0);
    }
    else if (!strcmp(attr,"funcs_tree_func_calls")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_funcs_tree_func_calls(self,0);
    }
    else if (!strcmp(attr,"funcs_tree_func_refs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_funcs_tree_func_refs(self,0);
    }
    else if (!strcmp(attr,"funcs_tree_funrefs_no_asm")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_funcs_tree_funrefs_no_asm(self,0);
    }
    else if (!strcmp(attr,"funcs_tree_funrefs_no_known")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_funcs_tree_funrefs_no_known(self,0);
    }
    else if (!strcmp(attr,"funcs_tree_funrefs_no_known_no_asm")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_funcs_tree_funrefs_no_known_no_asm(self,0);
    }
    else if (!strcmp(attr,"globs_tree_globalrefs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_globs_tree_globalrefs(self,0);
    }
    else if (!strcmp(attr,"types_tree_refs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_types_tree_refs(self,0);
    }
    else if (!strcmp(attr,"types_tree_usedrefs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_types_tree_usedrefs(self,0);
    }
    else if (!strcmp(attr,"static_funcs_map")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_static_funcs_map(self,0);
    }
    else if (!strcmp(attr,"init_data")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_init_data(self,0);
    }
    else if (!strcmp(attr,"known_data")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_known_data(self,0);
    }
    else if (!strcmp(attr,"BAS")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_BAS(self,0);
    }
    else if (!strcmp(attr,"func_fptrs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_get_func_fptrs(self,0);
    }
    else if (!strcmp(attr,"funcdecln")) {
        PYASSTR_DECREF(attr);
        return PyLong_FromUnsignedLong(__self->ftdb->funcdecls_count);
    }
    else if (!strcmp(attr,"typen")) {
        PYASSTR_DECREF(attr);
        return PyLong_FromUnsignedLong(__self->ftdb->types_count);
    }
    else if (!strcmp(attr,"sourcen")) {
        PYASSTR_DECREF(attr);
        return PyLong_FromUnsignedLong(__self->ftdb->sourceindex_table_count);
    }
    else if (!strcmp(attr,"globaln")) {
        PYASSTR_DECREF(attr);
        return PyLong_FromUnsignedLong(__self->ftdb->globals_count);
    }
    else if (!strcmp(attr,"unresolvedfuncn")) {
        PYASSTR_DECREF(attr);
        return PyLong_FromUnsignedLong(__self->ftdb->unresolvedfuncs_count);
    }
    else if (!strcmp(attr,"funcn")) {
        PYASSTR_DECREF(attr);
        return PyLong_FromUnsignedLong(__self->ftdb->funcs_count);
    }
    else if (!strcmp(attr,"fopn")) {
        PYASSTR_DECREF(attr);
        return PyLong_FromUnsignedLong(__self->ftdb->fops_count);
    }

    snprintf(errmsg,ERRMSG_BUFFER_SIZE,"Invalid attribute name: %s",attr);
    PyErr_SetString(libftdb_ftdbError, errmsg);
    PYASSTR_DECREF(attr);
    Py_RETURN_NONE;
}

int libftdb_ftdb_sq_contains(PyObject* self, PyObject* key) {

    libftdb_ftdb_object* __self = (libftdb_ftdb_object*)self;
    FTDB_MODULE_INIT_CHECK;

    if (!PyUnicode_Check(key)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in contains check (not a str)");
        return 0;
    }

    const char* attr = PyString_get_c_str(key);

    if (!strcmp(attr,"version")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"module")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"directory")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"release")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"sources")) {
        PYASSTR_DECREF(attr);
        return !!__self->ftdb->sourceindex_table;
    }
    else if (!strcmp(attr,"source_info")) {
        PYASSTR_DECREF(attr);
        return !!__self->ftdb->sourceindex_table;
    }
    else if (!strcmp(attr,"modules")) {
        PYASSTR_DECREF(attr);
        return !!__self->ftdb->moduleindex_table;
    }
    else if (!strcmp(attr,"module_info")) {
        PYASSTR_DECREF(attr);
        return !!__self->ftdb->moduleindex_table;
    }
    else if (!strcmp(attr,"funcs")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"funcdecls")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"unresolvedfuncs")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"globals")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"types")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"fops")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"funcs_tree_calls_no_asm")) {
        PYASSTR_DECREF(attr);
        return !!__self->ftdb->funcs_tree_calls_no_asm;
    }
    else if (!strcmp(attr,"funcs_tree_calls_no_known")) {
        PYASSTR_DECREF(attr);
        return !!__self->ftdb->funcs_tree_calls_no_known;
    }
    else if (!strcmp(attr,"funcs_tree_calls_no_known_no_asm")) {
        PYASSTR_DECREF(attr);
        return !!__self->ftdb->funcs_tree_calls_no_known_no_asm;
    }
    else if (!strcmp(attr,"funcs_tree_func_calls")) {
        PYASSTR_DECREF(attr);
        return !!__self->ftdb->funcs_tree_func_calls;
    }
    else if (!strcmp(attr,"funcs_tree_func_refs")) {
        PYASSTR_DECREF(attr);
        return !!__self->ftdb->funcs_tree_func_refs;
    }
    else if (!strcmp(attr,"funcs_tree_funrefs_no_asm")) {
        PYASSTR_DECREF(attr);
        return !!__self->ftdb->funcs_tree_funrefs_no_asm;
    }
    else if (!strcmp(attr,"funcs_tree_funrefs_no_known")) {
        PYASSTR_DECREF(attr);
        return !!__self->ftdb->funcs_tree_funrefs_no_known;
    }
    else if (!strcmp(attr,"funcs_tree_funrefs_no_known_no_asm")) {
        PYASSTR_DECREF(attr);
        return !!__self->ftdb->funcs_tree_funrefs_no_known_no_asm;
    }
    else if (!strcmp(attr,"globs_tree_globalrefs")) {
        PYASSTR_DECREF(attr);
        return !!__self->ftdb->globs_tree_globalrefs;
    }
    else if (!strcmp(attr,"types_tree_refs")) {
        PYASSTR_DECREF(attr);
        return !!__self->ftdb->types_tree_refs;
    }
    else if (!strcmp(attr,"types_tree_usedrefs")) {
        PYASSTR_DECREF(attr);
        return !!__self->ftdb->types_tree_usedrefs;
    }
    else if (!strcmp(attr,"static_funcs_map")) {
        PYASSTR_DECREF(attr);
        return !!__self->ftdb->static_funcs_map;
    }
    else if (!strcmp(attr,"init_data")) {
        PYASSTR_DECREF(attr);
        return !!__self->ftdb->init_data;
    }
    else if (!strcmp(attr,"known_data")) {
        PYASSTR_DECREF(attr);
        return !!__self->ftdb->known_data;
    }
    else if (!strcmp(attr,"BAS")) {
        PYASSTR_DECREF(attr);
        return !!__self->ftdb->BAS_data;
    }
    else if (!strcmp(attr,"func_fptrs")) {
        PYASSTR_DECREF(attr);
        return !!__self->ftdb->func_fptrs_data;
    }
    else if (!strcmp(attr,"funcdecln")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"typen")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"sourcen")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"globaln")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"unresolvedfuncn")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"funcn")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"fopn")) {
        PYASSTR_DECREF(attr);
        return 1;
    }

    PYASSTR_DECREF(attr);
    return 0;
}

PyObject* libftdb_ftdb_get_BAS_item_by_loc(libftdb_ftdb_object* self, PyObject* args, PyObject* kwargs) {

    const char* loc;
    if(!PyArg_ParseTuple(args, "s", &loc))
        return NULL;

    struct stringRef_entryMap_node* node = stringRef_entryMap_search(&self->ftdb->BAS_data_index,loc);
    if (!node) {
        Py_RETURN_NONE;
    }

    struct BAS_item* entry = (struct BAS_item*)node->entry;
    PyObject* py_BAS_entry = PyDict_New();
    FTDB_SET_ENTRY_STRING(py_BAS_entry,loc,entry->loc);
    FTDB_SET_ENTRY_STRING_ARRAY(py_BAS_entry,entries,entry->entries);
    return py_BAS_entry;
}

PyObject* libftdb_ftdb_get_func_map_entry__by_id(libftdb_ftdb_object* self, PyObject* args, PyObject* kwargs) {

    unsigned long id;
    if(!PyArg_ParseTuple(args, "k", &id))
        return NULL;

    struct ulong_entryMap_node* node = ulong_entryMap_search(&self->ftdb->static_funcs_map_index,id);
    if (!node) {
        Py_RETURN_NONE;
    }

    struct func_map_entry* entry = (struct func_map_entry*)node->entry;
    PyObject* py_func_map_entry = PyDict_New();
    FTDB_SET_ENTRY_ULONG(py_func_map_entry,id,entry->id);
    FTDB_SET_ENTRY_ULONG_ARRAY(py_func_map_entry,fids,entry->fids);
    return py_func_map_entry;
}

void libftdb_ftdb_sources_dealloc(libftdb_ftdb_sources_object* self) {

    Py_DecRef((PyObject*)self->py_ftdb);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_sources_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    libftdb_ftdb_sources_object* self;

    self = (libftdb_ftdb_sources_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->ftdb = (const struct ftdb*)PyLong_AsLong(PyTuple_GetItem(args,0));
        self->py_ftdb = (const libftdb_ftdb_object*)PyLong_AsLong(PyTuple_GetItem(args,1));
        Py_IncRef((PyObject*)self->py_ftdb);
    }

    return (PyObject *)self;
}

PyObject* libftdb_ftdb_sources_repr(PyObject* self) {

    static char repr[1024];

    libftdb_ftdb_sources_object* __self = (libftdb_ftdb_sources_object*)self;
    int written = snprintf(repr,1024,"<ftdbSources object at %lx : ",(uintptr_t)self);
    written+=snprintf(repr+written,1024-written,"%ld sources>",__self->ftdb->sourceindex_table_count);

    return PyUnicode_FromString(repr);
}

Py_ssize_t libftdb_ftdb_sources_sq_length(PyObject* self) {

    libftdb_ftdb_sources_object* __self = (libftdb_ftdb_sources_object*)self;
    return __self->ftdb->sourceindex_table_count;
}

PyObject* libftdb_ftdb_sources_mp_subscript(PyObject* self, PyObject* slice) {

    static char errmsg[ERRMSG_BUFFER_SIZE];
    libftdb_ftdb_sources_object* __self = (libftdb_ftdb_sources_object*)self;

    if (PyLong_Check(slice)) {
        unsigned long index = PyLong_AsUnsignedLong(slice);
        if (index>=__self->ftdb->sourceindex_table_count) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"source table index out of range: %ld\n",index);
            PyErr_SetString(libftdb_ftdbError, errmsg);
            return 0;
        }
        return PyUnicode_FromString(__self->ftdb->sourceindex_table[index]);
    }
    else if (PyUnicode_Check(slice)) {
        const char* key = PyString_get_c_str(slice);
        struct stringRefMap_node* node = stringRefMap_search(&__self->ftdb->sourcemap,key);
        if (!node) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"source table file missing: %s\n",key);
            PYASSTR_DECREF(key);
            PyErr_SetString(libftdb_ftdbError, errmsg);
            return 0;
        }
        PYASSTR_DECREF(key);
        return PyLong_FromUnsignedLong(node->value);
    }
    else {
        PyErr_SetString(libftdb_ftdbError, "Invalid subscript argument");
        return 0;
    }
}

int libftdb_ftdb_sources_sq_contains(PyObject* self, PyObject* key) {

    if (!PyUnicode_Check(key)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in source contains check (not a str)");
        return 0;
    }

    libftdb_ftdb_sources_object* __self = (libftdb_ftdb_sources_object*)self;
    const char* ckey = PyString_get_c_str(key);
    struct stringRefMap_node* node = stringRefMap_search(&__self->ftdb->sourcemap,ckey);
    PYASSTR_DECREF(ckey);
    if (node) return 1;
    return 0;
}

PyObject* libftdb_ftdb_sources_getiter(PyObject* self) {

    libftdb_ftdb_sources_object* __self = (libftdb_ftdb_sources_object*)self;

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
    PYTUPLE_SET_ULONG(args,1,0);
    PyObject *iter = PyObject_CallObject((PyObject *) &libftdb_ftdbSourcesIterType, args);
    Py_DecRef(args);
    return iter;
}

void libftdb_ftdb_sources_iter_dealloc(libftdb_ftdb_sources_iter_object* self) {

    Py_DecRef((PyObject*)self->sources);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_sources_iter_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    libftdb_ftdb_sources_iter_object* self;

    self = (libftdb_ftdb_sources_iter_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->sources = (libftdb_ftdb_sources_object*)PyLong_AsLong(PyTuple_GetItem(args,0));
        Py_IncRef((PyObject*)self->sources);
        self->index = PyLong_AsLong(PyTuple_GetItem(args,1));
    }

    return (PyObject *)self;
}

Py_ssize_t libftdb_ftdb_sources_iter_sq_length(PyObject* self) {

    libftdb_ftdb_sources_iter_object* __self = (libftdb_ftdb_sources_iter_object*)self;
    return __self->sources->ftdb->sourceindex_table_count;
}

PyObject* libftdb_ftdb_sources_iter_next(PyObject *self) {

    libftdb_ftdb_sources_iter_object* __self = (libftdb_ftdb_sources_iter_object*)self;

    if (__self->index >= __self->sources->ftdb->sourceindex_table_count) {
        /* Raising of standard StopIteration exception with empty value. */
        PyErr_SetNone(PyExc_StopIteration);
        return 0;
    }

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,__self->index);
    PYTUPLE_SET_STR(args,1,__self->sources->ftdb->sourceindex_table[__self->index]);
    __self->index++;
    return args;
}

void libftdb_ftdb_modules_dealloc(libftdb_ftdb_modules_object* self) {

    Py_DecRef((PyObject*)self->py_ftdb);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_modules_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    libftdb_ftdb_modules_object* self;

    self = (libftdb_ftdb_modules_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->ftdb = (const struct ftdb*)PyLong_AsLong(PyTuple_GetItem(args,0));
        self->py_ftdb = (const libftdb_ftdb_object*)PyLong_AsLong(PyTuple_GetItem(args,1));
        Py_IncRef((PyObject*)self->py_ftdb);
    }

    return (PyObject *)self;
}

PyObject* libftdb_ftdb_modules_repr(PyObject* self) {

    static char repr[1024];

    libftdb_ftdb_modules_object* __self = (libftdb_ftdb_modules_object*)self;
    int written = snprintf(repr,1024,"<ftdbModules object at %lx : ",(uintptr_t)self);
    written+=snprintf(repr+written,1024-written,"%ld modules>",__self->ftdb->moduleindex_table_count);

    return PyUnicode_FromString(repr);
}

Py_ssize_t libftdb_ftdb_modules_sq_length(PyObject* self) {

    libftdb_ftdb_modules_object* __self = (libftdb_ftdb_modules_object*)self;
    return __self->ftdb->moduleindex_table_count;
}

PyObject* libftdb_ftdb_modules_mp_subscript(PyObject* self, PyObject* slice) {

    static char errmsg[ERRMSG_BUFFER_SIZE];
    libftdb_ftdb_modules_object* __self = (libftdb_ftdb_modules_object*)self;

    if (PyLong_Check(slice)) {
        unsigned long index = PyLong_AsUnsignedLong(slice);
        if (index>=__self->ftdb->moduleindex_table_count) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"module table index out of range: %ld\n",index);
            PyErr_SetString(libftdb_ftdbError, errmsg);
            return 0;
        }
        return PyUnicode_FromString(__self->ftdb->moduleindex_table[index]);
    }
    else if (PyUnicode_Check(slice)) {
        const char* key = PyString_get_c_str(slice);
        struct stringRefMap_node* node = stringRefMap_search(&__self->ftdb->modulemap,key);
        if (!node) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"module table file missing: %s\n",key);
            PYASSTR_DECREF(key);
            PyErr_SetString(libftdb_ftdbError, errmsg);
            return 0;
        }
        PYASSTR_DECREF(key);
        return PyLong_FromUnsignedLong(node->value);
    }
    else {
        PyErr_SetString(libftdb_ftdbError, "Invalid subscript argument");
        return 0;
    }
}

int libftdb_ftdb_modules_sq_contains(PyObject* self, PyObject* key) {

    if (!PyUnicode_Check(key)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in module contains check (not a str)");
        return 0;
    }

    libftdb_ftdb_modules_object* __self = (libftdb_ftdb_modules_object*)self;
    const char* ckey = PyString_get_c_str(key);
    struct stringRefMap_node* node = stringRefMap_search(&__self->ftdb->modulemap,ckey);
    PYASSTR_DECREF(ckey);
    if (node) return 1;
    return 0;
}

PyObject* libftdb_ftdb_modules_getiter(PyObject* self) {

    libftdb_ftdb_modules_object* __self = (libftdb_ftdb_modules_object*)self;

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
    PYTUPLE_SET_ULONG(args,1,0);
    PyObject *iter = PyObject_CallObject((PyObject *) &libftdb_ftdbModulesIterType, args);
    Py_DecRef(args);
    return iter;
}

void libftdb_ftdb_modules_iter_dealloc(libftdb_ftdb_modules_iter_object* self) {

    Py_DecRef((PyObject*)self->modules);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_modules_iter_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    libftdb_ftdb_modules_iter_object* self;

    self = (libftdb_ftdb_modules_iter_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->modules = (libftdb_ftdb_modules_object*)PyLong_AsLong(PyTuple_GetItem(args,0));
        Py_IncRef((PyObject*)self->modules);
        self->index = PyLong_AsLong(PyTuple_GetItem(args,1));
    }

    return (PyObject *)self;
}

Py_ssize_t libftdb_ftdb_modules_iter_sq_length(PyObject* self) {

    libftdb_ftdb_modules_iter_object* __self = (libftdb_ftdb_modules_iter_object*)self;
    return __self->modules->ftdb->moduleindex_table_count;
}

PyObject* libftdb_ftdb_modules_iter_next(PyObject *self) {

    libftdb_ftdb_modules_iter_object* __self = (libftdb_ftdb_modules_iter_object*)self;

    if (__self->index >= __self->modules->ftdb->moduleindex_table_count) {
        /* Raising of standard StopIteration exception with empty value. */
        PyErr_SetNone(PyExc_StopIteration);
        return 0;
    }

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,__self->index);
    PYTUPLE_SET_STR(args,1,__self->modules->ftdb->moduleindex_table[__self->index]);
    __self->index++;
    return args;
}


void libftdb_ftdb_funcs_dealloc(libftdb_ftdb_funcs_object* self) {

    Py_DecRef((PyObject*)self->py_ftdb);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_funcs_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    libftdb_ftdb_funcs_object* self;

    self = (libftdb_ftdb_funcs_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->ftdb = (const struct ftdb*)PyLong_AsLong(PyTuple_GetItem(args,0));
        self->py_ftdb = (const libftdb_ftdb_object*)PyLong_AsLong(PyTuple_GetItem(args,1));
        Py_IncRef((PyObject*)self->py_ftdb);
    }

    return (PyObject *)self;
}

PyObject* libftdb_ftdb_funcs_repr(PyObject* self) {

    static char repr[1024];

    libftdb_ftdb_funcs_object* __self = (libftdb_ftdb_funcs_object*)self;
    int written = snprintf(repr,1024,"<ftdbFuncs object at %lx : ",(uintptr_t)self);
    written+=snprintf(repr+written,1024-written,"%ld funcs>",__self->ftdb->funcs_count);

    return PyUnicode_FromString(repr);
}

Py_ssize_t libftdb_ftdb_funcs_sq_length(PyObject* self) {

    libftdb_ftdb_funcs_object* __self = (libftdb_ftdb_funcs_object*)self;
    return __self->ftdb->funcs_count;
}

PyObject* libftdb_ftdb_funcs_getiter(PyObject* self) {

    libftdb_ftdb_funcs_object* __self = (libftdb_ftdb_funcs_object*)self;

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
    PYTUPLE_SET_ULONG(args,1,0); /* index */
    PyObject *iter = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncsIterType, args);

    Py_DecRef(args);
    return iter;
}

PyObject* libftdb_ftdb_funcs_mp_subscript(PyObject* self, PyObject* slice) {

    static char errmsg[ERRMSG_BUFFER_SIZE];
    libftdb_ftdb_funcs_object* __self = (libftdb_ftdb_funcs_object*)self;

    if (PyLong_Check(slice)) {
        unsigned long id = PyLong_AsUnsignedLong(slice);
        struct ulong_entryMap_node* node = ulong_entryMap_search(&__self->ftdb->frefmap, id);
        if (!node) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"invalid function id not present in the array: %lu\n",id);
            PyErr_SetString(libftdb_ftdbError, errmsg);
            return 0;
        }
        struct ftdb_func_entry* func_entry = (struct ftdb_func_entry*)node->entry;
        PyObject* args = PyTuple_New(2);
        PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
        PYTUPLE_SET_ULONG(args,1,func_entry->__index);
        PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncsEntryType, args);
        Py_DecRef(args);
        return entry;
    }
    else if (PyUnicode_Check(slice)) {
        const char* hash = PyString_get_c_str(slice);
        struct stringRef_entryMap_node* node = stringRef_entryMap_search(&__self->ftdb->fhrefmap, hash);
        if (!node) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"invalid function hash not present in the array: %s\n",hash);
            PYASSTR_DECREF(hash);
            PyErr_SetString(libftdb_ftdbError, errmsg);
            return 0;
        }
        PYASSTR_DECREF(hash);
        struct ftdb_func_entry* func_entry = (struct ftdb_func_entry*)node->entry;
        PyObject* args = PyTuple_New(2);
        PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
        PYTUPLE_SET_ULONG(args,1,func_entry->__index);
        PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncsEntryType, args);
        Py_DecRef(args);
        return entry;
    }
    else {
        PyErr_SetString(libftdb_ftdbError, "Invalid subscript argument");
        return 0;
    }
}

PyObject* libftdb_ftdb_funcs_entry_by_id(libftdb_ftdb_funcs_object *self, PyObject *args) {

    unsigned long id;
    if(!PyArg_ParseTuple(args, "k", &id))
        return NULL;

    static char errmsg[ERRMSG_BUFFER_SIZE];

    struct ulong_entryMap_node* node = ulong_entryMap_search(&self->ftdb->frefmap, id);
    if (!node) {
        snprintf(errmsg,ERRMSG_BUFFER_SIZE,"invalid function id not present in the array: %lu\n",id);
        PyErr_SetString(libftdb_ftdbError, errmsg);
        return 0;
    }
    struct ftdb_func_entry* func_entry = (struct ftdb_func_entry*)node->entry;
    PyObject* _args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(_args,0,(uintptr_t)self);
    PYTUPLE_SET_ULONG(_args,1,func_entry->__index);
    PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncsEntryType, _args);
    Py_DecRef(_args);
    return entry;
}

static PyObject* libftdb_ftdb_funcs_contains_id_internal(libftdb_ftdb_funcs_object *self, unsigned long id) {

    struct ulong_entryMap_node* node = ulong_entryMap_search(&self->ftdb->frefmap, id);
    if (node) {
        Py_RETURN_TRUE;
    }
    else {
        Py_RETURN_FALSE;
    }
}

PyObject* libftdb_ftdb_funcs_contains_id(libftdb_ftdb_funcs_object *self, PyObject *args) {
    
    unsigned long id;
    if(!PyArg_ParseTuple(args, "k", &id))
        return NULL;

    return libftdb_ftdb_funcs_contains_id_internal(self,id);
}

PyObject* libftdb_ftdb_funcs_entry_by_hash(libftdb_ftdb_funcs_object *self, PyObject *args) {

    static char errmsg[ERRMSG_BUFFER_SIZE];
    const char* hash;
    if(!PyArg_ParseTuple(args, "s", &hash))
        return NULL;

    struct stringRef_entryMap_node* node = stringRef_entryMap_search(&self->ftdb->fhrefmap, hash);
    if (!node) {
        snprintf(errmsg,ERRMSG_BUFFER_SIZE,"invalid function hash not present in the array: %s\n",hash);
        PyErr_SetString(libftdb_ftdbError, errmsg);
        return 0;
    }
    struct ftdb_func_entry* func_entry = (struct ftdb_func_entry*)node->entry;
    PyObject* _args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(_args,0,(uintptr_t)self);
    PYTUPLE_SET_ULONG(_args,1,func_entry->__index);
    PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncsEntryType, _args);
    Py_DecRef(_args);
    return entry;
}

static PyObject* libftdb_ftdb_funcs_contains_hash_internal(libftdb_ftdb_funcs_object *self, const char *hash) {

    struct stringRef_entryMap_node* node = stringRef_entryMap_search(&self->ftdb->fhrefmap, hash);
    if (node) {
        Py_RETURN_TRUE;
    }
    else {
        Py_RETURN_FALSE;
    }
}

PyObject* libftdb_ftdb_funcs_contains_hash(libftdb_ftdb_funcs_object *self, PyObject *args) {
    
    const char* hash;
    if(!PyArg_ParseTuple(args, "s", &hash))
        return NULL;
    
    return libftdb_ftdb_funcs_contains_hash_internal(self,hash);
}

PyObject* libftdb_ftdb_funcs_entry_by_name(libftdb_ftdb_funcs_object *self, PyObject *args) {

    const char* name;
    if(!PyArg_ParseTuple(args, "s", &name))
        return NULL;

    static char errmsg[ERRMSG_BUFFER_SIZE];

    struct stringRef_entryListMap_node* node = stringRef_entryListMap_search(&self->ftdb->fnrefmap, name);
    if (!node) {
        snprintf(errmsg,ERRMSG_BUFFER_SIZE,"invalid function name not present in the array: %s\n",name);
        PyErr_SetString(libftdb_ftdbError, errmsg);
        return 0;
    }
    struct ftdb_func_entry** func_entry_list = (struct ftdb_func_entry**)node->entry_list;
    PyObject* entry_list = PyList_New(0);
    for (unsigned long i=0; i<node->entry_count; ++i) {
        struct ftdb_func_entry* func_entry = (struct ftdb_func_entry*)(func_entry_list[i]);
        PyObject* args = PyTuple_New(2);
        PYTUPLE_SET_ULONG(args,0,(uintptr_t)self);
        PYTUPLE_SET_ULONG(args,1,func_entry->__index);
        PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncsEntryType, args);
        Py_DecRef(args);
        PyList_Append(entry_list,entry);
        Py_DecRef(entry);
    }
    return entry_list;
}

static PyObject* libftdb_ftdb_funcs_contains_name_internal(libftdb_ftdb_funcs_object *self, const char *name) {

    struct stringRef_entryListMap_node* node = stringRef_entryListMap_search(&self->ftdb->fnrefmap, name);
    if (node) {
        Py_RETURN_TRUE;
    }
    else {
        Py_RETURN_FALSE;
    }
}

PyObject* libftdb_ftdb_funcs_contains_name(libftdb_ftdb_funcs_object *self, PyObject *args) {
    
    const char* name;
    if(!PyArg_ParseTuple(args, "s", &name))
        return NULL;

    return libftdb_ftdb_funcs_contains_name_internal(self,name);
}

int libftdb_ftdb_funcs_sq_contains(PyObject* self, PyObject* key) {

    libftdb_ftdb_funcs_object* __self = (libftdb_ftdb_funcs_object*)self;

    if (PyUnicode_Check(key)) {
        /* Check name */
        const char* name;
        if(!PyArg_Parse(key, "s", &name))
            return -1;

        PyObject* v = libftdb_ftdb_funcs_contains_name_internal(__self,name);
        if (v) {
            return PyObject_IsTrue(v);
        }
    }
    else if (PyLong_Check(key)) {
        /* Check id */
        unsigned long id = PyLong_AsUnsignedLong(key);
        PyObject* v = libftdb_ftdb_funcs_contains_id_internal(__self,id);
        if (v) {
            return PyObject_IsTrue(v);
        }
    }
    else if (PyTuple_Check(key)) {
        /* Check hash */
        const char* hash;
        if(!PyArg_ParseTuple(key, "s", &hash))
            return -1;

        PyObject* v = libftdb_ftdb_funcs_contains_hash_internal(__self,hash);
        if (v) {
            return PyObject_IsTrue(v);
        }
    }

    PyErr_SetString(libftdb_ftdbError, "Invalid key type in contains check (not a str, tuple or integer)");
    return 0;
}

PyObject* libftdb_ftdb_funcs_get_refcount(PyObject* self, void* closure) {
    return PyLong_FromLong(self->ob_refcnt);
}

void libftdb_ftdb_funcs_iter_dealloc(libftdb_ftdb_funcs_iter_object* self) {

    Py_DecRef((PyObject*)self->funcs);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_funcs_iter_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    libftdb_ftdb_funcs_iter_object* self;

    self = (libftdb_ftdb_funcs_iter_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->funcs = (libftdb_ftdb_funcs_object*)PyLong_AsLong(PyTuple_GetItem(args,0));
        Py_IncRef((PyObject*)self->funcs);
        self->index = PyLong_AsLong(PyTuple_GetItem(args,1));
    }

    return (PyObject *)self;
}

Py_ssize_t libftdb_ftdb_funcs_iter_sq_length(PyObject* self) {

    libftdb_ftdb_funcs_iter_object* __self = (libftdb_ftdb_funcs_iter_object*)self;
    return __self->funcs->ftdb->funcs_count;
}

PyObject* libftdb_ftdb_funcs_iter_next(PyObject *self) {

    libftdb_ftdb_funcs_iter_object* __self = (libftdb_ftdb_funcs_iter_object*)self;

    if (__self->index >= __self->funcs->ftdb->funcs_count) {
        /* Raising of standard StopIteration exception with empty value. */
        PyErr_SetNone(PyExc_StopIteration);
        return 0;
    }

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self->funcs);
    PYTUPLE_SET_ULONG(args,1,__self->index);
    PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncsEntryType, args);
    Py_DecRef(args);
    __self->index++;
    return entry;
}

void libftdb_ftdb_func_entry_dealloc(libftdb_ftdb_func_entry_object* self) {

    Py_DecRef((PyObject*)self->funcs);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_func_entry_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    libftdb_ftdb_func_entry_object* self;

    self = (libftdb_ftdb_func_entry_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->funcs = (const libftdb_ftdb_funcs_object*)PyLong_AsLong(PyTuple_GetItem(args,0));
        Py_IncRef((PyObject*)self->funcs);
        unsigned long index = PyLong_AsLong(PyTuple_GetItem(args,1));
        if (index>=self->funcs->ftdb->funcs_count) {
            PyErr_SetString(libftdb_ftdbError, "func entry index out of bounds");
            return 0;
        }
        self->index = index;
        self->entry = &self->funcs->ftdb->funcs[self->index];
    }

    return (PyObject *)self;
}

PyObject* libftdb_ftdb_func_entry_repr(PyObject* self) {

    static char repr[1024];

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;
    int written = snprintf(repr,1024,"<ftdbFuncEntry object at %lx : ",(uintptr_t)self);
    written+=snprintf(repr+written,1024-written,"id:%lu|name:%s>",__self->entry->id,__self->entry->name);

    return PyUnicode_FromString(repr);
}

PyObject* libftdb_ftdb_func_entry_json(libftdb_ftdb_func_entry_object *self, PyObject *args) {

    PyObject* json_entry = PyDict_New();

    FTDB_SET_ENTRY_STRING(json_entry,name,self->entry->name);
    FTDB_SET_ENTRY_STRING_OPTIONAL(json_entry,namespace,self->entry->__namespace);
    FTDB_SET_ENTRY_ULONG(json_entry,id,self->entry->id);
    FTDB_SET_ENTRY_ULONG(json_entry,fid,self->entry->fid);
    FTDB_SET_ENTRY_ULONG_ARRAY(json_entry,fids,self->entry->fids);
    FTDB_SET_ENTRY_ULONG_ARRAY_OPTIONAL(json_entry,mids,self->entry->mids);
    FTDB_SET_ENTRY_ULONG(json_entry,nargs,self->entry->nargs);
    FTDB_SET_ENTRY_BOOL(json_entry,variadic,self->entry->isvariadic);
    FTDB_SET_ENTRY_STRING(json_entry,firstNonDeclStmt,self->entry->firstNonDeclStmt);
    FTDB_SET_ENTRY_BOOL_OPTIONAL(json_entry,inline,self->entry->isinline);
    FTDB_SET_ENTRY_BOOL_OPTIONAL(json_entry,template,self->entry->istemplate);
    FTDB_SET_ENTRY_STRING_OPTIONAL(json_entry,classOuterFn,self->entry->classOuterFn);
    FTDB_SET_ENTRY_ENUM_TO_STRING(json_entry,linkage,self->entry->linkage,functionLinkage);
    FTDB_SET_ENTRY_BOOL_OPTIONAL(json_entry,member,self->entry->ismember);
    FTDB_SET_ENTRY_STRING_OPTIONAL(json_entry,class,self->entry->__class);
    FTDB_SET_ENTRY_ULONG_OPTIONAL(json_entry,classid,self->entry->classid);
    FTDB_SET_ENTRY_STRING_ARRAY(json_entry,attributes,self->entry->attributes);
    FTDB_SET_ENTRY_STRING(json_entry,hash,self->entry->hash);
    FTDB_SET_ENTRY_STRING(json_entry,cshash,self->entry->cshash);
    FTDB_SET_ENTRY_STRING_OPTIONAL(json_entry,template_parameters,self->entry->template_parameters);
    FTDB_SET_ENTRY_STRING(json_entry,body,self->entry->body);
    FTDB_SET_ENTRY_STRING(json_entry,unpreprocessed_body,self->entry->unpreprocessed_body);
    FTDB_SET_ENTRY_STRING(json_entry,declbody,self->entry->declbody);
    FTDB_SET_ENTRY_STRING(json_entry,signature,self->entry->signature);
    FTDB_SET_ENTRY_STRING(json_entry,declhash,self->entry->declhash);
    FTDB_SET_ENTRY_STRING(json_entry,location,self->entry->location);
    FTDB_SET_ENTRY_STRING(json_entry,start_loc,self->entry->start_loc);
    FTDB_SET_ENTRY_STRING(json_entry,end_loc,self->entry->end_loc);
    FTDB_SET_ENTRY_ULONG(json_entry,refcount,self->entry->refcount);

    PyObject* literals = PyDict_New();
    FTDB_SET_ENTRY_INT64_ARRAY(literals,integer,self->entry->integer_literals);
    FTDB_SET_ENTRY_INT_ARRAY(literals,character,self->entry->character_literals);
    FTDB_SET_ENTRY_FLOAT_ARRAY(literals,floating,self->entry->floating_literals);
    FTDB_SET_ENTRY_STRING_ARRAY(literals,string,self->entry->string_literals);
    FTDB_SET_ENTRY_PYOBJECT(json_entry,literals,literals);

    FTDB_SET_ENTRY_ULONG(json_entry,declcount,self->entry->declcount);

    PyObject* taint = PyDict_New();
    for (unsigned long i=0; i<self->entry->taint_count; ++i) {
        struct taint_data* taint_data = &self->entry->taint[i];
        PyObject* taint_list = PyList_New(0);
        for (unsigned long j=0; j<taint_data->taint_list_count; ++j) {
            struct taint_element* taint_element = &taint_data->taint_list[j];
            PyObject* py_taint_element = PyList_New(0);
            PYLIST_ADD_ULONG(py_taint_element,taint_element->taint_level);
            PYLIST_ADD_ULONG(py_taint_element,taint_element->varid);
            PYLIST_ADD_PYOBJECT(taint_list,py_taint_element);
        }
        PyObject* key = PyUnicode_FromFormat("%lu",i);
        PyDict_SetItem(taint,key,taint_list);
        Py_DecRef(taint_list);
        Py_DecRef(key);
    }
    FTDB_SET_ENTRY_PYOBJECT(json_entry,taint,taint);

    FTDB_SET_ENTRY_ULONG_ARRAY(json_entry,calls,self->entry->calls);
    PyObject* call_info = PyList_New(0);
    for (unsigned long i=0; i<self->entry->calls_count; ++i) {
        struct call_info* call_info_entry = &self->entry->call_info[i];
        PyObject* py_callinfo = PyDict_New();
        FTDB_SET_ENTRY_STRING(py_callinfo,start,call_info_entry->start);
        FTDB_SET_ENTRY_STRING(py_callinfo,end,call_info_entry->end);
        FTDB_SET_ENTRY_ULONG(py_callinfo,ord,call_info_entry->ord);
        FTDB_SET_ENTRY_STRING(py_callinfo,expr,call_info_entry->expr);
        FTDB_SET_ENTRY_STRING(py_callinfo,loc,call_info_entry->loc);
        FTDB_SET_ENTRY_INT64_OPTIONAL(py_callinfo,csid,call_info_entry->csid);
        FTDB_SET_ENTRY_ULONG_ARRAY(py_callinfo,args,call_info_entry->args);
        PYLIST_ADD_PYOBJECT(call_info,py_callinfo);
    }
    FTDB_SET_ENTRY_PYOBJECT(json_entry,call_info,call_info);

    PyObject* callrefs = PyList_New(0);
    for (unsigned long i=0; i<self->entry->calls_count; ++i) {
        struct callref_info* callref_info = &self->entry->callrefs[i];
        PyObject* py_callref_info = PyList_New(0);
        for (unsigned long j=0; j<callref_info->callarg_count; ++j) {
            struct callref_data* callref_data = &callref_info->callarg[j];
            PyObject* py_callref_data = PyDict_New();
            FTDB_SET_ENTRY_ENUM_TO_STRING(py_callref_data,type,callref_data->type,exprType);
            FTDB_SET_ENTRY_ULONG(py_callref_data,pos,callref_data->pos);
            if (callref_data->id) {
                FTDB_SET_ENTRY_ULONG_OPTIONAL(py_callref_data,id,callref_data->id);
            }
            else if (callref_data->integer_literal) {
                FTDB_SET_ENTRY_INT64_OPTIONAL(py_callref_data,id,callref_data->integer_literal);
            }
            else if (callref_data->character_literal) {
                FTDB_SET_ENTRY_INT_OPTIONAL(py_callref_data,id,callref_data->character_literal);
            }
            else if (callref_data->floating_literal) {
                FTDB_SET_ENTRY_FLOAT_OPTIONAL(py_callref_data,id,callref_data->floating_literal);
            }
            else if (callref_data->string_literal) {
                FTDB_SET_ENTRY_STRING_OPTIONAL(py_callref_data,id,callref_data->string_literal);
            }
            PYLIST_ADD_PYOBJECT(py_callref_info,py_callref_data);
        }
        PYLIST_ADD_PYOBJECT(callrefs,py_callref_info);
    }
    FTDB_SET_ENTRY_PYOBJECT(json_entry,callrefs,callrefs);

    PyObject* refcalls = PyList_New(0);
    for (unsigned long i=0; i<self->entry->refcalls_count; ++i) {
        struct refcall* refcall = &self->entry->refcalls[i];
        PyObject* refcall_info = PyList_New(0);
        if (refcall->ismembercall) {
            PYLIST_ADD_ULONG(refcall_info,refcall->fid);
            PYLIST_ADD_ULONG(refcall_info,refcall->cid);
            PYLIST_ADD_ULONG(refcall_info,refcall->field_index);
        }
        else {
            PYLIST_ADD_ULONG(refcall_info,refcall->fid);
        }
        PYLIST_ADD_PYOBJECT(refcalls,refcall_info);
    }
    FTDB_SET_ENTRY_PYOBJECT(json_entry,refcalls,refcalls);

    PyObject* refcall_info = PyList_New(0);
    for (unsigned long i=0; i<self->entry->refcalls_count; ++i) {
        struct call_info* refcall_info_entry = &self->entry->refcall_info[i];
        PyObject* py_refcallinfo = PyDict_New();
        FTDB_SET_ENTRY_STRING(py_refcallinfo,start,refcall_info_entry->start);
        FTDB_SET_ENTRY_STRING(py_refcallinfo,end,refcall_info_entry->end);
        FTDB_SET_ENTRY_ULONG(py_refcallinfo,ord,refcall_info_entry->ord);
        FTDB_SET_ENTRY_STRING(py_refcallinfo,expr,refcall_info_entry->expr);
        FTDB_SET_ENTRY_INT64_OPTIONAL(py_refcallinfo,csid,refcall_info_entry->csid);
        FTDB_SET_ENTRY_STRING_OPTIONAL(py_refcallinfo,loc,refcall_info_entry->loc);
        FTDB_SET_ENTRY_ULONG_ARRAY(py_refcallinfo,args,refcall_info_entry->args);
        PYLIST_ADD_PYOBJECT(refcall_info,py_refcallinfo);
    }
    FTDB_SET_ENTRY_PYOBJECT(json_entry,refcall_info,refcall_info);

    PyObject* refcallrefs = PyList_New(0);
    for (unsigned long i=0; i<self->entry->refcalls_count; ++i) {
        struct callref_info* refcallref_info = &self->entry->refcallrefs[i];
        PyObject* py_refcallref_info = PyList_New(0);
        for (unsigned long j=0; j<refcallref_info->callarg_count; ++j) {
            struct callref_data* refcallref_data = &refcallref_info->callarg[j];
            PyObject* py_refcallref_data = PyDict_New();
            FTDB_SET_ENTRY_ENUM_TO_STRING(py_refcallref_data,type,refcallref_data->type,exprType);
            FTDB_SET_ENTRY_ULONG(py_refcallref_data,pos,refcallref_data->pos);
            if (refcallref_data->id) {
                FTDB_SET_ENTRY_ULONG_OPTIONAL(py_refcallref_data,id,refcallref_data->id);
            }
            else if (refcallref_data->integer_literal) {
                FTDB_SET_ENTRY_INT64_OPTIONAL(py_refcallref_data,id,refcallref_data->integer_literal);
            }
            else if (refcallref_data->character_literal) {
                FTDB_SET_ENTRY_INT_OPTIONAL(py_refcallref_data,id,refcallref_data->character_literal);
            }
            else if (refcallref_data->floating_literal) {
                FTDB_SET_ENTRY_FLOAT_OPTIONAL(py_refcallref_data,id,refcallref_data->floating_literal);
            }
            else if (refcallref_data->string_literal) {
                FTDB_SET_ENTRY_STRING_OPTIONAL(py_refcallref_data,id,refcallref_data->string_literal);
            }
            PYLIST_ADD_PYOBJECT(py_refcallref_info,py_refcallref_data);
        }
        PYLIST_ADD_PYOBJECT(refcallrefs,py_refcallref_info);
    }
    FTDB_SET_ENTRY_PYOBJECT(json_entry,refcallrefs,refcallrefs);

    PyObject* switches = PyList_New(0);
    for (unsigned long i=0; i<self->entry->switches_count; ++i) {
        struct switch_info* switch_info_entry = &self->entry->switches[i];
        PyObject* py_switch_info = PyDict_New();
        FTDB_SET_ENTRY_STRING(py_switch_info,condition,switch_info_entry->condition);
        PyObject* cases = PyList_New(0);
        for (unsigned long j=0; j<switch_info_entry->cases_count; ++j) {
            struct case_info* case_info = &switch_info_entry->cases[j];
            PyObject* py_case_info = PyList_New(0);
            PYLIST_ADD_LONG(py_case_info,case_info->lhs.expr_value);
            PYLIST_ADD_STRING(py_case_info,case_info->lhs.enum_code);
            PYLIST_ADD_STRING(py_case_info,case_info->lhs.macro_code);
            PYLIST_ADD_STRING(py_case_info,case_info->lhs.raw_code);
            if (case_info->rhs) {
                PYLIST_ADD_LONG(py_case_info,case_info->rhs->expr_value);
                PYLIST_ADD_STRING(py_case_info,case_info->rhs->enum_code);
                PYLIST_ADD_STRING(py_case_info,case_info->rhs->macro_code);
                PYLIST_ADD_STRING(py_case_info,case_info->rhs->raw_code);
            }
            PYLIST_ADD_PYOBJECT(cases,py_case_info);
        }
        FTDB_SET_ENTRY_PYOBJECT(py_switch_info,cases,cases);
        PYLIST_ADD_PYOBJECT(switches,py_switch_info);
    }
    FTDB_SET_ENTRY_PYOBJECT(json_entry,switches,switches);

    PyObject* csmap = PyList_New(0);
    for (unsigned long i=0; i<self->entry->csmap_count; ++i) {
        struct csitem* csitem = &self->entry->csmap[i];
        PyObject* py_csitem = PyDict_New();
        FTDB_SET_ENTRY_INT64(py_csitem,pid,csitem->pid);
        FTDB_SET_ENTRY_ULONG(py_csitem,id,csitem->id);
        FTDB_SET_ENTRY_STRING(py_csitem,cf,csitem->cf);
        PYLIST_ADD_PYOBJECT(csmap,py_csitem);
    }
    FTDB_SET_ENTRY_PYOBJECT(json_entry,csmap,csmap);

    if(self->entry->macro_expansions){
        PyObject* macro_expansions = PyList_New(0);
        for (unsigned long i=0; i<self->entry->macro_expansions_count; ++i) {
            struct mexp_info* mexp_info = &self->entry->macro_expansions[i];
            PyObject* py_mexp_info = PyDict_New();
            FTDB_SET_ENTRY_ULONG(py_mexp_info,pos,mexp_info->pos);
            FTDB_SET_ENTRY_ULONG(py_mexp_info,len,mexp_info->len);
            FTDB_SET_ENTRY_STRING(py_mexp_info,text,mexp_info->text);
            PYLIST_ADD_PYOBJECT(macro_expansions,py_mexp_info);
        }
        FTDB_SET_ENTRY_PYOBJECT(json_entry,macro_expansions,macro_expansions);
    }

    PyObject* locals = PyList_New(0);
    for (unsigned long i=0; i<self->entry->locals_count; ++i) {
        struct local_info* local_info_entry = &self->entry->locals[i];
        PyObject* py_local_entry = PyDict_New();
        FTDB_SET_ENTRY_ULONG(py_local_entry,id,local_info_entry->id);
        FTDB_SET_ENTRY_STRING(py_local_entry,name,local_info_entry->name);
        FTDB_SET_ENTRY_ULONG(py_local_entry,type,local_info_entry->type);
        FTDB_SET_ENTRY_BOOL(py_local_entry,parm,local_info_entry->isparm);
        FTDB_SET_ENTRY_BOOL(py_local_entry,static,local_info_entry->isstatic);
        FTDB_SET_ENTRY_BOOL(py_local_entry,used,local_info_entry->isused);
        FTDB_SET_ENTRY_STRING(py_local_entry,location,local_info_entry->location);
        FTDB_SET_ENTRY_INT64_OPTIONAL(py_local_entry,csid,local_info_entry->csid);
        PYLIST_ADD_PYOBJECT(locals,py_local_entry);
    }
    FTDB_SET_ENTRY_PYOBJECT(json_entry,locals,locals);

    PyObject* derefs = PyList_New(0);
    for (unsigned long i=0; i<self->entry->derefs_count; ++i) {
        struct deref_info* deref_info_entry = &self->entry->derefs[i];
        PyObject* py_deref_entry = PyDict_New();
        FTDB_SET_ENTRY_ENUM_TO_STRING(py_deref_entry,kind,deref_info_entry->kind,exprType);
        FTDB_SET_ENTRY_INT64_OPTIONAL(py_deref_entry,offset,deref_info_entry->offset);
        FTDB_SET_ENTRY_ULONG_OPTIONAL(py_deref_entry,basecnt,deref_info_entry->basecnt);
        PyObject* offsetrefs = PyList_New(0);
        for (unsigned long j=0; j<deref_info_entry->offsetrefs_count; ++j) {
            struct offsetref_info* offsetref_info = &deref_info_entry->offsetrefs[j];
            PyObject* py_offsetref_entry = PyDict_New();
            FTDB_SET_ENTRY_ENUM_TO_STRING(py_offsetref_entry,kind,offsetref_info->kind,exprType);
            if (offsetref_info->kind==EXPR_STRING) {
                FTDB_SET_ENTRY_STRING(py_offsetref_entry,id,offsetref_info->id_string);
            }
            else if (offsetref_info->kind==EXPR_FLOATING) {
                FTDB_SET_ENTRY_FLOAT(py_offsetref_entry,id,offsetref_info->id_float);
            }
            else {
                FTDB_SET_ENTRY_INT64(py_offsetref_entry,id,offsetref_info->id_integer);
            }
            FTDB_SET_ENTRY_ULONG_OPTIONAL(py_offsetref_entry,mi,offsetref_info->mi);
            FTDB_SET_ENTRY_ULONG_OPTIONAL(py_offsetref_entry,di,offsetref_info->di);
            FTDB_SET_ENTRY_ULONG_OPTIONAL(py_offsetref_entry,cast,offsetref_info->cast);
            PYLIST_ADD_PYOBJECT(offsetrefs,py_offsetref_entry);
        }
        FTDB_SET_ENTRY_PYOBJECT(py_deref_entry,offsetrefs,offsetrefs);
        FTDB_SET_ENTRY_STRING(py_deref_entry,expr,deref_info_entry->expr);
        FTDB_SET_ENTRY_INT64(py_deref_entry,csid,deref_info_entry->csid);
        FTDB_SET_ENTRY_ULONG_ARRAY(py_deref_entry,ord,deref_info_entry->ord);
        FTDB_SET_ENTRY_INT64_ARRAY_OPTIONAL(py_deref_entry,member,deref_info_entry->member);
        FTDB_SET_ENTRY_ULONG_ARRAY_OPTIONAL(py_deref_entry,type,deref_info_entry->type);
        FTDB_SET_ENTRY_ULONG_ARRAY_OPTIONAL(py_deref_entry,access,deref_info_entry->access);
        FTDB_SET_ENTRY_INT64_ARRAY_OPTIONAL(py_deref_entry,shift,deref_info_entry->shift);
        FTDB_SET_ENTRY_INT64_ARRAY_OPTIONAL(py_deref_entry,mcall,deref_info_entry->mcall);
        PYLIST_ADD_PYOBJECT(derefs,py_deref_entry);
    }
    FTDB_SET_ENTRY_PYOBJECT(json_entry,derefs,derefs);

    PyObject* ifs = PyList_New(0);
    for (unsigned long i=0; i<self->entry->ifs_count; ++i) {
        struct if_info* if_entry = &self->entry->ifs[i];
        PyObject* py_if_entry = PyDict_New();
        FTDB_SET_ENTRY_INT64(py_if_entry,csid,if_entry->csid);
        PyObject* if_refs = PyList_New(0);
        for (unsigned long j=0; j<if_entry->refs_count; ++j) {
            struct ifref_info* ifref_info = &if_entry->refs[j];
            PyObject* py_ifref_info = PyDict_New();
            FTDB_SET_ENTRY_ENUM_TO_STRING(py_ifref_info,type,ifref_info->type,exprType);
            if (ifref_info->id) {
                FTDB_SET_ENTRY_ULONG_OPTIONAL(py_ifref_info,id,ifref_info->id);
            }
            else if (ifref_info->integer_literal) {
                FTDB_SET_ENTRY_INT64_OPTIONAL(py_ifref_info,id,ifref_info->integer_literal);
            }
            else if (ifref_info->character_literal) {
                FTDB_SET_ENTRY_INT_OPTIONAL(py_ifref_info,id,ifref_info->character_literal);
            }
            else if (ifref_info->floating_literal) {
                FTDB_SET_ENTRY_FLOAT_OPTIONAL(py_ifref_info,id,ifref_info->floating_literal);
            }
            else if (ifref_info->string_literal) {
                FTDB_SET_ENTRY_STRING_OPTIONAL(py_ifref_info,id,ifref_info->string_literal);
            }
            PYLIST_ADD_PYOBJECT(if_refs,py_ifref_info);
        }
        FTDB_SET_ENTRY_PYOBJECT(py_if_entry,refs,if_refs);
        PYLIST_ADD_PYOBJECT(ifs,py_if_entry);
    }
    FTDB_SET_ENTRY_PYOBJECT(json_entry,ifs,ifs);

    PyObject* asms = PyList_New(0);
    for (unsigned long i=0; i<self->entry->asms_count; ++i) {
        struct asm_info* asm_info = &self->entry->asms[i];
        PyObject* py_asm_entry = PyDict_New();
        FTDB_SET_ENTRY_INT64(py_asm_entry,csid,asm_info->csid);
        FTDB_SET_ENTRY_STRING(py_asm_entry,str,asm_info->str);
        PYLIST_ADD_PYOBJECT(asms,py_asm_entry);
    }
    FTDB_SET_ENTRY_PYOBJECT(json_entry,asm,asms);

    FTDB_SET_ENTRY_ULONG_ARRAY(json_entry,globalrefs,self->entry->globalrefs);

    PyObject* globalrefInfo = PyList_New(0);
    for (unsigned long i=0; i<self->entry->globalrefs_count; ++i) {
        struct globalref_data* globalref_data = &self->entry->globalrefInfo[i];
        PyObject* refs = PyList_New(0);
        for (unsigned long j=0; j<globalref_data->refs_count; ++j) {
            struct globalref_info* globalref_info = &globalref_data->refs[j];
            PyObject* py_globalref_info = PyDict_New();
            FTDB_SET_ENTRY_STRING(py_globalref_info,start,globalref_info->start);
            FTDB_SET_ENTRY_STRING(py_globalref_info,end,globalref_info->end);
            PYLIST_ADD_PYOBJECT(refs,py_globalref_info);
        }
        PYLIST_ADD_PYOBJECT(globalrefInfo,refs);
    }
    FTDB_SET_ENTRY_PYOBJECT(json_entry,globalrefInfo,globalrefInfo);

    FTDB_SET_ENTRY_ULONG_ARRAY(json_entry,funrefs,self->entry->funrefs);
    FTDB_SET_ENTRY_ULONG_ARRAY(json_entry,refs,self->entry->refs);
    FTDB_SET_ENTRY_ULONG_ARRAY(json_entry,decls,self->entry->decls);
    FTDB_SET_ENTRY_ULONG_ARRAY(json_entry,types,self->entry->types);

    return json_entry;
}

PyObject* libftdb_ftdb_func_entry_get_object_refcount(PyObject* self, void* closure) {
    return PyLong_FromLong(self->ob_refcnt);
}

PyObject* libftdb_ftdb_func_entry_get_id(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    return PyLong_FromUnsignedLong(__self->entry->id);
}

PyObject* libftdb_ftdb_func_entry_get_hash(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    return PyUnicode_FromString(__self->entry->hash);
}

PyObject* libftdb_ftdb_func_entry_get_name(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    return PyUnicode_FromString(__self->entry->name);
}

PyObject* libftdb_ftdb_func_entry_has_namespace(libftdb_ftdb_func_entry_object *self, PyObject *args) {

    if (self->entry->__namespace) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_func_entry_has_classOuterFn(libftdb_ftdb_func_entry_object *self, PyObject *args) {

    if (self->entry->classOuterFn) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;

}

PyObject* libftdb_ftdb_func_entry_has_class(libftdb_ftdb_func_entry_object *self, PyObject *args) {

    if ((self->entry->__class)||(self->entry->classid)) {
        if (!self->entry->__class) {
            PyErr_SetString(libftdb_ftdbError, "No 'class' field in function entry");
            return 0;
        }
        if (!self->entry->classid) {
            PyErr_SetString(libftdb_ftdbError, "No 'classid' field in function entry");
            return 0;
        }
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;

}

PyObject* libftdb_ftdb_func_entry_get_namespace(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    if (!__self->entry->__namespace) {
        PyErr_SetString(libftdb_ftdbError, "No 'namespace' field in function entry");
        return 0;
    }

    return PyUnicode_FromString(__self->entry->__namespace);
}

PyObject* libftdb_ftdb_func_entry_get_fid(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    return PyLong_FromUnsignedLong(__self->entry->fid);
}

PyObject* libftdb_ftdb_func_entry_get_fids(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* fids = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->fids_count; ++i) {
        PYLIST_ADD_ULONG(fids,__self->entry->fids[i]);
    }
    return fids;
}

PyObject* libftdb_ftdb_func_entry_get_mids(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    if (!__self->entry->mids) {
        Py_RETURN_NONE;
    }

    PyObject* mids = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->mids_count; ++i) {
        PYLIST_ADD_ULONG(mids,__self->entry->mids[i]);
    }
    return mids;
}

PyObject* libftdb_ftdb_func_entry_get_nargs(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    return PyLong_FromUnsignedLong(__self->entry->nargs);
}

PyObject* libftdb_ftdb_func_entry_get_variadic(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    if (__self->entry->isvariadic) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_func_entry_get_firstNonDeclStmt(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    return PyUnicode_FromString(__self->entry->firstNonDeclStmt);
}

PyObject* libftdb_ftdb_func_entry_get_inline(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    if ((__self->entry->isinline) && (*__self->entry->isinline)) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_func_entry_get_template(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    if ((__self->entry->istemplate) && (*__self->entry->istemplate)) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_func_entry_get_classOuterFn(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    if (!__self->entry->classOuterFn) {
        PyErr_SetString(libftdb_ftdbError, "No 'classOuterFn' field in function entry");
        return 0;
    }

    return PyUnicode_FromString(__self->entry->classOuterFn);
}

PyObject* libftdb_ftdb_func_entry_get_linkage(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    return PyLong_FromLong((long)__self->entry->linkage);
}

PyObject* libftdb_ftdb_func_entry_get_linkage_string(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    return PyUnicode_FromString(set_functionLinkage(__self->entry->linkage));
}

PyObject* libftdb_ftdb_func_entry_get_member(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    if ((__self->entry->ismember) && (*__self->entry->ismember)) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_func_entry_get_class(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    if (!__self->entry->__class) {
        PyErr_SetString(libftdb_ftdbError, "No 'class' field in function entry");
        return 0;
    }

    return PyUnicode_FromString(__self->entry->__class);
}

PyObject* libftdb_ftdb_func_entry_get_classid(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    if (!__self->entry->classid) {
        PyErr_SetString(libftdb_ftdbError, "No 'classid' field in function entry");
        return 0;
    }

    return PyLong_FromUnsignedLong(*__self->entry->classid);
}

PyObject* libftdb_ftdb_func_entry_get_attributes(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* attributes = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->attributes_count; ++i) {
        PYLIST_ADD_STRING(attributes,__self->entry->attributes[i]);
    }
    return attributes;
}

PyObject* libftdb_ftdb_func_entry_get_cshash(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    return PyUnicode_FromString(__self->entry->cshash);
}

PyObject* libftdb_ftdb_func_entry_get_template_parameters(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    if (!__self->entry->template_parameters) {
        PyErr_SetString(libftdb_ftdbError, "No 'template_parameters' field in function entry");
        return 0;
    }

    return PyUnicode_FromString(__self->entry->template_parameters);
}

PyObject* libftdb_ftdb_func_entry_get_body(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    return PyUnicode_FromString(__self->entry->body);
}

PyObject* libftdb_ftdb_func_entry_get_unpreprocessed_body(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    return PyUnicode_FromString(__self->entry->unpreprocessed_body);
}

PyObject* libftdb_ftdb_func_entry_get_declbody(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    return PyUnicode_FromString(__self->entry->declbody);
}

PyObject* libftdb_ftdb_func_entry_get_signature(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    return PyUnicode_FromString(__self->entry->signature);
}

PyObject* libftdb_ftdb_func_entry_get_declhash(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    return PyUnicode_FromString(__self->entry->declhash);
}

PyObject* libftdb_ftdb_func_entry_get_location(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    return PyUnicode_FromString(__self->entry->location);
}

PyObject* libftdb_ftdb_func_entry_get_start_loc(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    return PyUnicode_FromString(__self->entry->start_loc);
}

PyObject* libftdb_ftdb_func_entry_get_end_loc(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    return PyUnicode_FromString(__self->entry->end_loc);
}

PyObject* libftdb_ftdb_func_entry_get_refcount(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    return PyLong_FromUnsignedLong(__self->entry->refcount);
}

PyObject* libftdb_ftdb_func_entry_get_declcount(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    return PyLong_FromUnsignedLong(__self->entry->declcount);
}

PyObject* libftdb_ftdb_func_entry_get_literals(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* literals = PyDict_New();
    FTDB_SET_ENTRY_INT64_ARRAY(literals,integer,__self->entry->integer_literals);
    FTDB_SET_ENTRY_FLOAT_ARRAY(literals,floating,__self->entry->floating_literals);
    FTDB_SET_ENTRY_UINT_ARRAY(literals,character,__self->entry->character_literals);
    FTDB_SET_ENTRY_STRING_ARRAY(literals,string,__self->entry->string_literals);

    return literals;
}

PyObject* libftdb_ftdb_func_entry_get_integer_literals(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* integer_literals = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->integer_literals_count; ++i) {
        PYLIST_ADD_LONG(integer_literals,__self->entry->integer_literals[i]);
    }
    return integer_literals;
}

PyObject* libftdb_ftdb_func_entry_get_character_literals(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* character_literals = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->character_literals_count; ++i) {
        PYLIST_ADD_ULONG(character_literals,__self->entry->character_literals[i]);
    }
    return character_literals;
}

PyObject* libftdb_ftdb_func_entry_get_floating_literals(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* floating_literals = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->floating_literals_count; ++i) {
        PYLIST_ADD_FLOAT(floating_literals,__self->entry->floating_literals[i]);
    }
    return floating_literals;
}

PyObject* libftdb_ftdb_func_entry_get_string_literals(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* string_literals = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->string_literals_count; ++i) {
        PYLIST_ADD_STRING(string_literals,__self->entry->string_literals[i]);
    }
    return string_literals;
}

PyObject* libftdb_ftdb_func_entry_get_taint(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* taint = PyDict_New();

    for (unsigned long i=0; i<__self->entry->taint_count; ++i) {
        struct taint_data* taint_data = &__self->entry->taint[i];
        PyObject* py_taint_list = PyList_New(0);
        for (unsigned long j=0; j<taint_data->taint_list_count; ++j) {
            struct taint_element* taint_element = &taint_data->taint_list[j];
            PyObject* py_taint_element = PyList_New(0);
            PYLIST_ADD_ULONG(py_taint_element,taint_element->taint_level);
            PYLIST_ADD_ULONG(py_taint_element,taint_element->varid);
            PyList_Append(py_taint_list,py_taint_element);
            Py_DecRef(py_taint_element);
        }
        PyObject* key = PyUnicode_FromFormat("%lu",i);
        PyDict_SetItem(taint, key, py_taint_list);
        Py_DecRef(key);
        Py_DecRef(py_taint_list);
    }
    return taint;
}

PyObject* libftdb_ftdb_func_entry_get_calls(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* calls = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->calls_count; ++i) {
        PYLIST_ADD_ULONG(calls,__self->entry->calls[i]);
    }
    return calls;
}

PyObject* libftdb_ftdb_func_entry_get_call_info(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* call_info = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->calls_count; ++i) {
        PyObject* args = PyTuple_New(4);
        PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
        PYTUPLE_SET_ULONG(args,1,__self->index);
        PYTUPLE_SET_ULONG(args,2,i);
        PYTUPLE_SET_ULONG(args,3,0);
        PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncCallInfoEntryType, args);
        Py_DecRef(args);
        PyList_Append(call_info,entry);
        Py_DecRef(entry);
    }
    return call_info;
}

PyObject* libftdb_ftdb_func_entry_get_callrefs(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* callrefs = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->calls_count; ++i) {
        struct callref_info* callref_info = &__self->entry->callrefs[i];
        PyObject* py_callref_info = PyList_New(0);
        for (unsigned long j=0; j<callref_info->callarg_count; ++j) {
            struct callref_data* callref_data = &callref_info->callarg[j];
            PyObject* py_callref_data = PyDict_New();
            FTDB_SET_ENTRY_ENUM_TO_STRING(py_callref_data,type,callref_data->type,exprType);
            FTDB_SET_ENTRY_ULONG(py_callref_data,pos,callref_data->pos);
            if (callref_data->id) {
                FTDB_SET_ENTRY_ULONG_OPTIONAL(py_callref_data,id,callref_data->id);
            }
            else if (callref_data->integer_literal) {
                FTDB_SET_ENTRY_INT64_OPTIONAL(py_callref_data,id,callref_data->integer_literal);
            }
            else if (callref_data->character_literal) {
                FTDB_SET_ENTRY_UINT_OPTIONAL(py_callref_data,id,callref_data->character_literal);
            }
            else if (callref_data->floating_literal) {
                FTDB_SET_ENTRY_FLOAT_OPTIONAL(py_callref_data,id,callref_data->floating_literal);
            }
            else if (callref_data->string_literal) {
                FTDB_SET_ENTRY_STRING_OPTIONAL(py_callref_data,id,callref_data->string_literal);
            }
            PyList_Append(py_callref_info,py_callref_data);
            Py_DecRef(py_callref_data);
        }
        PyList_Append(callrefs,py_callref_info);
        Py_DecRef(py_callref_info);
    }

    return callrefs;
}

PyObject* libftdb_ftdb_func_entry_get_refcalls(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* refcalls = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->refcalls_count; ++i) {
        struct refcall* refcall = &__self->entry->refcalls[i];
        if (refcall->ismembercall) {
            PyObject* refcall_info = PyList_New(0);
            PYLIST_ADD_ULONG(refcall_info,refcall->fid);
            PYLIST_ADD_ULONG(refcall_info,refcall->cid);
            PYLIST_ADD_ULONG(refcall_info,refcall->field_index);
            PyList_Append(refcalls,refcall_info);
            Py_DecRef(refcall_info);
        }
        else {
            PyObject* refcall_info = PyList_New(0);
            PYLIST_ADD_ULONG(refcall_info,refcall->fid);
            PyList_Append(refcalls,refcall_info);
            Py_DecRef(refcall_info);
        }
    }
    return refcalls;
}

PyObject* libftdb_ftdb_func_entry_get_refcall_info(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* call_info = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->refcalls_count; ++i) {
        PyObject* args = PyTuple_New(4);
        PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
        PYTUPLE_SET_ULONG(args,1,__self->index);
        PYTUPLE_SET_ULONG(args,2,i);
        PYTUPLE_SET_ULONG(args,3,1);
        PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncCallInfoEntryType, args);
        Py_DecRef(args);
        PyList_Append(call_info,entry);
        Py_DecRef(entry);
    }
    return call_info;
}

PyObject* libftdb_ftdb_func_entry_get_refcallrefs(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* refcallrefs = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->refcalls_count; ++i) {
        struct callref_info* refcallref_info = &__self->entry->refcallrefs[i];
        PyObject* py_refcallref_info = PyList_New(0);
        for (unsigned long j=0; j<refcallref_info->callarg_count; ++j) {
            struct callref_data* refcallref_data = &refcallref_info->callarg[j];
            PyObject* py_refcallref_data = PyDict_New();
            FTDB_SET_ENTRY_ENUM_TO_STRING(py_refcallref_data,type,refcallref_data->type,exprType);
            FTDB_SET_ENTRY_ULONG(py_refcallref_data,pos,refcallref_data->pos);
            if (refcallref_data->id) {
                FTDB_SET_ENTRY_ULONG_OPTIONAL(py_refcallref_data,id,refcallref_data->id);
            }
            else if (refcallref_data->integer_literal) {
                FTDB_SET_ENTRY_INT64_OPTIONAL(py_refcallref_data,id,refcallref_data->integer_literal);
            }
            else if (refcallref_data->character_literal) {
                FTDB_SET_ENTRY_UINT_OPTIONAL(py_refcallref_data,id,refcallref_data->character_literal);
            }
            else if (refcallref_data->floating_literal) {
                FTDB_SET_ENTRY_FLOAT_OPTIONAL(py_refcallref_data,id,refcallref_data->floating_literal);
            }
            else if (refcallref_data->string_literal) {
                FTDB_SET_ENTRY_STRING_OPTIONAL(py_refcallref_data,id,refcallref_data->string_literal);
            }
            PyList_Append(py_refcallref_info,py_refcallref_data);
            Py_DecRef(py_refcallref_data);
        }
        PyList_Append(refcallrefs,py_refcallref_info);
        Py_DecRef(py_refcallref_info);
    }

    return refcallrefs;
}

PyObject* libftdb_ftdb_func_entry_get_switches(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* switch_info = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->switches_count; ++i) {
        PyObject* args = PyTuple_New(3);
        PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
        PYTUPLE_SET_ULONG(args,1,__self->index);
        PYTUPLE_SET_ULONG(args,2,i);
        PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncSwitchInfoEntryType, args);
        Py_DecRef(args);
        PyList_Append(switch_info,entry);
        Py_DecRef(entry);
    }
    return switch_info;
}

PyObject* libftdb_ftdb_func_entry_get_csmap(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* csmap = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->csmap_count; ++i) {
        struct csitem* csitem = &__self->entry->csmap[i];
        PyObject* py_csitem = PyDict_New();
        FTDB_SET_ENTRY_INT64(py_csitem,pid,csitem->pid);
        FTDB_SET_ENTRY_ULONG(py_csitem,id,csitem->id);
        FTDB_SET_ENTRY_STRING(py_csitem,cf,csitem->cf);
        PyList_Append(csmap,py_csitem);
        Py_DecRef(py_csitem);
    }
    return csmap;
}

PyObject* libftdb_ftdb_func_entry_get_macro_expansions(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    if (!__self->entry->macro_expansions) {
        PyErr_SetString(libftdb_ftdbError, "No 'macro_expansions' field in func entry");
        return 0;
    }

    PyObject* macro_expansions = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->macro_expansions_count; ++i) {
        struct mexp_info* mexp_info = &__self->entry->macro_expansions[i];
        PyObject* py_mexp_info = PyDict_New();
        FTDB_SET_ENTRY_INT64(py_mexp_info,pos,mexp_info->pos);
        FTDB_SET_ENTRY_ULONG(py_mexp_info,len,mexp_info->len);
        FTDB_SET_ENTRY_STRING(py_mexp_info,text,mexp_info->text);
        PyList_Append(macro_expansions,py_mexp_info);
        Py_DecRef(py_mexp_info);
    }
    return macro_expansions;
}

PyObject* libftdb_ftdb_func_entry_get_locals(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* local_info = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->locals_count; ++i) {
        PyObject* args = PyTuple_New(3);
        PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
        PYTUPLE_SET_ULONG(args,1,__self->index);
        PYTUPLE_SET_ULONG(args,2,i);
        PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncLocalInfoEntryType, args);
        Py_DecRef(args);
        PyList_Append(local_info,entry);
        Py_DecRef(entry);
    }
    return local_info;
}

PyObject* libftdb_ftdb_func_entry_get_derefs(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* derefs_info = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->derefs_count; ++i) {
        PyObject* args = PyTuple_New(3);
        PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
        PYTUPLE_SET_ULONG(args,1,__self->index);
        PYTUPLE_SET_ULONG(args,2,i);
        PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncDerefInfoEntryType, args);
        Py_DecRef(args);
        PyList_Append(derefs_info,entry);
        Py_DecRef(entry);
    }
    return derefs_info;
}

PyObject* libftdb_ftdb_func_entry_get_ifs(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* ifs_info = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->ifs_count; ++i) {
        PyObject* args = PyTuple_New(3);
        PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
        PYTUPLE_SET_ULONG(args,1,__self->index);
        PYTUPLE_SET_ULONG(args,2,i);
        PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncIfInfoEntryType, args);
        Py_DecRef(args);
        PyList_Append(ifs_info,entry);
        Py_DecRef(entry);
    }
    return ifs_info;
}

PyObject* libftdb_ftdb_func_entry_get_asms(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* asms = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->asms_count; ++i) {
        struct asm_info* asm_item = &__self->entry->asms[i];
        PyObject* py_asm_item = PyDict_New();
        FTDB_SET_ENTRY_INT64(py_asm_item,csid,asm_item->csid);
        FTDB_SET_ENTRY_STRING(py_asm_item,str,asm_item->str);
        PyList_Append(asms,py_asm_item);
        Py_DecRef(py_asm_item);
    }
    return asms;
}

PyObject* libftdb_ftdb_func_entry_get_globalrefs(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* globalrefs = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->globalrefs_count; ++i) {
        PYLIST_ADD_ULONG(globalrefs,__self->entry->globalrefs[i]);
    }
    return globalrefs;
}

PyObject* libftdb_ftdb_func_entry_get_globalrefInfo(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* globalrefInfo = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->globalrefs_count; ++i) {
        struct globalref_data* globalref_data = &__self->entry->globalrefInfo[i];
        PyObject* py_globalref_data = PyList_New(0);
        for (unsigned long j=0; j<globalref_data->refs_count; ++j) {
            struct globalref_info* globalref_info = &globalref_data->refs[j];
            PyObject* py_globalref_info = PyDict_New();
            FTDB_SET_ENTRY_STRING(py_globalref_info,start,globalref_info->start);
            FTDB_SET_ENTRY_STRING(py_globalref_info,end,globalref_info->end);
            PyList_Append(py_globalref_data,py_globalref_info);
            Py_DecRef(py_globalref_info);
        }
        PyList_Append(globalrefInfo,py_globalref_data);
        Py_DecRef(py_globalref_data);
    }
    return globalrefInfo;
}

PyObject* libftdb_ftdb_func_entry_get_funrefs(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* funrefs = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->funrefs_count; ++i) {
        PYLIST_ADD_ULONG(funrefs,__self->entry->funrefs[i]);
    }
    return funrefs;
}

PyObject* libftdb_ftdb_func_entry_get_refs(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* refs = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->refs_count; ++i) {
        PYLIST_ADD_ULONG(refs,__self->entry->refs[i]);
    }
    return refs;
}

PyObject* libftdb_ftdb_func_entry_get_decls(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* decls = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->decls_count; ++i) {
        PYLIST_ADD_ULONG(decls,__self->entry->decls[i]);
    }
    return decls;
}

PyObject* libftdb_ftdb_func_entry_get_types(PyObject* self, void* closure) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;

    PyObject* types = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->types_count; ++i) {
        PYLIST_ADD_ULONG(types,__self->entry->types[i]);
    }
    return types;
}

PyObject* libftdb_ftdb_func_entry_mp_subscript(PyObject* self, PyObject* slice) {

    static char errmsg[ERRMSG_BUFFER_SIZE];

    if (!PyUnicode_Check(slice)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in property mapping (not a str)");
        Py_RETURN_NONE;
    }

    const char* attr = PyString_get_c_str(slice);

    if (!strcmp(attr,"id")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_id(self,0);
    }
    else if (!strcmp(attr,"hash")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_hash(self,0);
    }
    else if (!strcmp(attr,"name")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_name(self,0);
    }
    else if (!strcmp(attr,"namespace")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_namespace(self,0);
    }
    else if (!strcmp(attr,"fid")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_fid(self,0);
    }
    else if (!strcmp(attr,"fids")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_fids(self,0);
    }
    else if (!strcmp(attr,"mids")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_mids(self,0);
    }
    else if (!strcmp(attr,"nargs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_nargs(self,0);
    }
    else if (!strcmp(attr,"variadic")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_variadic(self,0);
    }
    else if (!strcmp(attr,"firstNonDeclStmt")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_firstNonDeclStmt(self,0);
    }
    else if (!strcmp(attr,"inline")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_inline(self,0);
    }
    else if (!strcmp(attr,"template")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_template(self,0);
    }
    else if (!strcmp(attr,"classOuterFn")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_classOuterFn(self,0);
    }
    else if (!strcmp(attr,"linkage")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_linkage_string(self,0);
    }
    else if (!strcmp(attr,"member")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_member(self,0);
    }
    else if (!strcmp(attr,"class")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_class(self,0);
    }
    else if (!strcmp(attr,"classid")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_classid(self,0);
    }
    else if (!strcmp(attr,"attributes")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_attributes(self,0);
    }
    else if (!strcmp(attr,"cshash")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_cshash(self,0);
    }
    else if (!strcmp(attr,"template_parameters")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_template_parameters(self,0);
    }
    else if (!strcmp(attr,"body")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_body(self,0);
    }
    else if (!strcmp(attr,"unpreprocessed_body")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_unpreprocessed_body(self,0);
    }
    else if (!strcmp(attr,"declbody")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_declbody(self,0);
    }
    else if (!strcmp(attr,"signature")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_signature(self,0);
    }
    else if (!strcmp(attr,"declhash")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_declhash(self,0);
    }
    else if (!strcmp(attr,"location")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_location(self,0);
    }
    else if (!strcmp(attr,"start_loc")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_start_loc(self,0);
    }
    else if (!strcmp(attr,"end_loc")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_end_loc(self,0);
    }
    else if (!strcmp(attr,"refcount")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_refcount(self,0);
    }
    else if (!strcmp(attr,"declcount")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_declcount(self,0);
    }
    else if (!strcmp(attr,"literals")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_literals(self,0);
    }
    else if (!strcmp(attr,"integer_literals")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_integer_literals(self,0);
    }
    else if (!strcmp(attr,"character_literals")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_character_literals(self,0);
    }
    else if (!strcmp(attr,"floating_literals")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_floating_literals(self,0);
    }
    else if (!strcmp(attr,"string_literals")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_string_literals(self,0);
    }
    else if (!strcmp(attr,"taint")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_taint(self,0);
    }
    else if (!strcmp(attr,"calls")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_calls(self,0);
    }
    else if (!strcmp(attr,"call_info")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_call_info(self,0);
    }
    else if (!strcmp(attr,"callrefs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_callrefs(self,0);
    }
    else if (!strcmp(attr,"refcalls")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_refcalls(self,0);
    }
    else if (!strcmp(attr,"refcall_info")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_refcall_info(self,0);
    }
    else if (!strcmp(attr,"refcallrefs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_refcallrefs(self,0);
    }
    else if (!strcmp(attr,"switches")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_switches(self,0);
    }
    else if (!strcmp(attr,"csmap")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_csmap(self,0);
    }
    else if (!strcmp(attr,"macro_expansions")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_macro_expansions(self,0);
    }
    else if (!strcmp(attr,"locals")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_locals(self,0);
    }
    else if (!strcmp(attr,"derefs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_derefs(self,0);
    }
    else if (!strcmp(attr,"ifs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_ifs(self,0);
    }
    else if (!strcmp(attr,"asm")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_asms(self,0);
    }
    else if (!strcmp(attr,"globalrefs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_globalrefs(self,0);
    }
    else if (!strcmp(attr,"globalrefInfo")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_globalrefInfo(self,0);
    }
    else if (!strcmp(attr,"funrefs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_funrefs(self,0);
    }
    else if (!strcmp(attr,"refs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_refs(self,0);
    }
    else if (!strcmp(attr,"decls")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_decls(self,0);
    }
    else if (!strcmp(attr,"types")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_entry_get_types(self,0);
    }

    snprintf(errmsg,ERRMSG_BUFFER_SIZE,"Invalid attribute name: %s",attr);
    PyErr_SetString(libftdb_ftdbError, errmsg);
    PYASSTR_DECREF(attr);
    Py_RETURN_NONE;
}

int libftdb_ftdb_func_entry_sq_contains(PyObject* self, PyObject* slice) {

    if (!PyUnicode_Check(slice)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in contains check (not a str)");
        return 0;
    }

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;
    const char* attr = PyString_get_c_str(slice);

    if (!strcmp(attr,"id")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"hash")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"name")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"namespace")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->__namespace;
    }
    else if (!strcmp(attr,"fid")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"fids")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"mids")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"nargs")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"variadic")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"firstNonDeclStmt")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"inline")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->isinline;
    }
    else if (!strcmp(attr,"template")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->istemplate;
    }
    else if (!strcmp(attr,"classOuterFn")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->classOuterFn;
    }
    else if (!strcmp(attr,"linkage")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"member")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->ismember;
    }
    else if (!strcmp(attr,"class")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->__class;
    }
    else if (!strcmp(attr,"classid")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->classid;
    }
    else if (!strcmp(attr,"attributes")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"cshash")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"template_parameters")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->template_parameters;
    }
    else if (!strcmp(attr,"body")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"unpreprocessed_body")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"declbody")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"signature")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"declhash")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"location")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"start_loc")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"end_loc")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"refcount")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"declcount")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"literals")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"integer_literals")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"character_literals")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"floating_literals")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"string_literals")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"taint")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"calls")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"call_info")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"callrefs")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"refcalls")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"refcall_info")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"refcallrefs")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"switches")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"csmap")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"macro_expansions")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->macro_expansions;
    }
    else if (!strcmp(attr,"locals")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"derefs")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"ifs")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"asm")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"globalrefs")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"globalrefInfo")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"funrefs")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"refs")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"decls")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"types")) {
        PYASSTR_DECREF(attr);
        return 1;
    }

    PYASSTR_DECREF(attr);
    return 0;
}

PyObject* libftdb_ftdb_func_entry_deepcopy(PyObject* self, PyObject* memo) {

    Py_INCREF(self);
    return (PyObject *)self;
}

Py_hash_t libftdb_ftdb_func_entry_hash(PyObject *o) {

    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)o;
    return __self->index;
}

PyObject* libftdb_ftdb_func_entry_richcompare(PyObject *self, PyObject *other, int op) {
    if (!PyObject_IsInstance(other, (PyObject *)&libftdb_ftdbFuncsEntryType)) {
        Py_RETURN_FALSE;
    }
    libftdb_ftdb_func_entry_object* __self = (libftdb_ftdb_func_entry_object*)self;
    libftdb_ftdb_func_entry_object* __other = (libftdb_ftdb_func_entry_object*)other;
    Py_RETURN_RICHCOMPARE_internal(__self->index, __other->index , op);
}

void libftdb_ftdb_func_callinfo_entry_dealloc(libftdb_ftdb_func_callinfo_entry_object* self) {

    Py_DecRef((PyObject*)self->func_entry);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_func_callinfo_entry_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {


    static char errmsg[ERRMSG_BUFFER_SIZE];
    libftdb_ftdb_func_callinfo_entry_object* self;

    self = (libftdb_ftdb_func_callinfo_entry_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->func_entry = (const libftdb_ftdb_func_entry_object*)PyLong_AsLong(PyTuple_GetItem(args,0));
        Py_IncRef((PyObject*)self->func_entry);
        unsigned long func_index = PyLong_AsLong(PyTuple_GetItem(args,1));
        if (func_index>=self->func_entry->funcs->ftdb->funcs_count) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"func entry index out of bounds: %lu\n",func_index);
            PyErr_SetString(libftdb_ftdbError, errmsg);
            return 0;
        }
        self->func_index = func_index;
        unsigned long entry_index = PyLong_AsLong(PyTuple_GetItem(args,2));
        self->is_refcall = PyLong_AsUnsignedLong(PyTuple_GetItem(args,3));

        if (self->is_refcall==0) {
            if (entry_index>=self->func_entry->funcs->ftdb->funcs[func_index].calls_count) {
                snprintf(errmsg,ERRMSG_BUFFER_SIZE,"callinfo entry index out of bounds: %lu@%lu\n",func_index,entry_index);
                PyErr_SetString(libftdb_ftdbError,errmsg);
                return 0;
            }
            self->entry_index = entry_index;
            self->entry = &self->func_entry->funcs->ftdb->funcs[self->func_index].call_info[self->entry_index];
        }
        else {
            if (entry_index>=self->func_entry->funcs->ftdb->funcs[func_index].refcalls_count) {
                snprintf(errmsg,ERRMSG_BUFFER_SIZE,"refcallinfo entry index out of bounds: %lu@%lu\n",func_index,entry_index);
                PyErr_SetString(libftdb_ftdbError,errmsg);
                return 0;
            }
            self->entry_index = entry_index;
            self->entry = &self->func_entry->funcs->ftdb->funcs[self->func_index].refcall_info[self->entry_index];
        }
    }

    return (PyObject *)self;
}

PyObject* libftdb_ftdb_func_callinfo_entry_repr(PyObject* self) {

    static char repr[1024];

    libftdb_ftdb_func_callinfo_entry_object* __self = (libftdb_ftdb_func_callinfo_entry_object*)self;
    int written = snprintf(repr,1024,"<ftdbFuncCallInfoEntry object at %lx : ",(uintptr_t)self);
    written+=snprintf(repr+written,1024-written,"fdx:%lu|edx:%lu>",__self->func_index,__self->entry_index);

    return PyUnicode_FromString(repr);
}

PyObject* libftdb_ftdb_func_callinfo_entry_get_start(PyObject* self, void* closure) {

    libftdb_ftdb_func_callinfo_entry_object* __self = (libftdb_ftdb_func_callinfo_entry_object*)self;
    return PyUnicode_FromString(__self->entry->start);
}

PyObject* libftdb_ftdb_func_callinfo_entry_get_end(PyObject* self, void* closure) {

    libftdb_ftdb_func_callinfo_entry_object* __self = (libftdb_ftdb_func_callinfo_entry_object*)self;
    return PyUnicode_FromString(__self->entry->end);
}

PyObject* libftdb_ftdb_func_callinfo_entry_get_ord(PyObject* self, void* closure) {

    libftdb_ftdb_func_callinfo_entry_object* __self = (libftdb_ftdb_func_callinfo_entry_object*)self;
    return PyLong_FromUnsignedLong(__self->entry->ord);
}

PyObject* libftdb_ftdb_func_callinfo_entry_get_expr(PyObject* self, void* closure) {

    libftdb_ftdb_func_callinfo_entry_object* __self = (libftdb_ftdb_func_callinfo_entry_object*)self;
    return PyUnicode_FromString(__self->entry->expr);
}

PyObject* libftdb_ftdb_func_callinfo_entry_get_loc(PyObject* self, void* closure) {

    libftdb_ftdb_func_callinfo_entry_object* __self = (libftdb_ftdb_func_callinfo_entry_object*)self;
    if (__self->entry->loc) {
        return PyUnicode_FromString(__self->entry->loc);
    }
    else {
        Py_RETURN_NONE;
    }
}

PyObject* libftdb_ftdb_func_callinfo_entry_get_csid(PyObject* self, void* closure) {

    libftdb_ftdb_func_callinfo_entry_object* __self = (libftdb_ftdb_func_callinfo_entry_object*)self;
    if (__self->entry->csid) {
        return PyLong_FromLong(*__self->entry->csid);
    }
    else {
        Py_RETURN_NONE;
    }
}

PyObject* libftdb_ftdb_func_callinfo_entry_get_args(PyObject* self, void* closure) {

    libftdb_ftdb_func_callinfo_entry_object* __self = (libftdb_ftdb_func_callinfo_entry_object*)self;

    PyObject* args = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->args_count; ++i) {
        PYLIST_ADD_ULONG(args,__self->entry->args[i]);
    }
    return args;
}

PyObject* libftdb_ftdb_func_callinfo_entry_json(libftdb_ftdb_func_callinfo_entry_object *self, PyObject *args) {

    PyObject* py_callinfo_entry = PyDict_New();

    FTDB_SET_ENTRY_STRING(py_callinfo_entry,start,self->entry->start);
    FTDB_SET_ENTRY_STRING(py_callinfo_entry,end,self->entry->end);
    FTDB_SET_ENTRY_ULONG(py_callinfo_entry,ord,self->entry->ord);
    FTDB_SET_ENTRY_STRING(py_callinfo_entry,expr,self->entry->expr);
    FTDB_SET_ENTRY_STRING_OPTIONAL(py_callinfo_entry,loc,self->entry->loc);
    FTDB_SET_ENTRY_INT64_OPTIONAL(py_callinfo_entry,csid,self->entry->csid);
    PyObject* py_args = PyList_New(0);
    for (unsigned long i=0; i<self->entry->args_count; ++i) {
        PYLIST_ADD_ULONG(py_args,self->entry->args[i]);
    }
    FTDB_SET_ENTRY_PYOBJECT(py_callinfo_entry,args,py_args);
    return py_callinfo_entry;
}

PyObject* libftdb_ftdb_func_callinfo_entry_mp_subscript(PyObject* self, PyObject* slice) {

    static char errmsg[ERRMSG_BUFFER_SIZE];

    if (!PyUnicode_Check(slice)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in property mapping (not a str)");
        Py_RETURN_NONE;
    }

    const char* attr = PyString_get_c_str(slice);

    if (!strcmp(attr,"start")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_callinfo_entry_get_start(self,0);
    }
    else if (!strcmp(attr,"end")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_callinfo_entry_get_end(self,0);
    }
    else if (!strcmp(attr,"ord")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_callinfo_entry_get_ord(self,0);
    }
    else if (!strcmp(attr,"expr")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_callinfo_entry_get_expr(self,0);
    }
    else if (!strcmp(attr,"loc")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_callinfo_entry_get_loc(self,0);
    }
    else if (!strcmp(attr,"csid")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_callinfo_entry_get_csid(self,0);
    }
    else if (!strcmp(attr,"args")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_callinfo_entry_get_args(self,0);
    }

    snprintf(errmsg,ERRMSG_BUFFER_SIZE,"Invalid attribute name: %s",attr);
    PyErr_SetString(libftdb_ftdbError, errmsg);
    PYASSTR_DECREF(attr);
    Py_RETURN_NONE;
}

int libftdb_ftdb_func_callinfo_entry_sq_contains(PyObject* self, PyObject* key) {

    if (!PyUnicode_Check(key)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in contains check (not a str)");
        return 0;
    }

    const char* attr = PyString_get_c_str(key);
    libftdb_ftdb_func_callinfo_entry_object* __self = (libftdb_ftdb_func_callinfo_entry_object*)self;

    if (!strcmp(attr,"start")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"end")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"ord")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"expr")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"loc")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->loc;
    }
    else if (!strcmp(attr,"csid")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"args")) {
        PYASSTR_DECREF(attr);
        return 1;
    }

    PYASSTR_DECREF(attr);
    return 0;
}

void libftdb_ftdb_func_switchinfo_entry_dealloc(libftdb_ftdb_func_switchinfo_entry_object* self) {

    Py_DecRef((PyObject*)self->func_entry);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_func_switchinfo_entry_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    static char errmsg[ERRMSG_BUFFER_SIZE];
    libftdb_ftdb_func_switchinfo_entry_object* self;

    self = (libftdb_ftdb_func_switchinfo_entry_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->func_entry = (const libftdb_ftdb_func_entry_object*)PyLong_AsLong(PyTuple_GetItem(args,0));
        Py_IncRef((PyObject*)self->func_entry);
        unsigned long func_index = PyLong_AsLong(PyTuple_GetItem(args,1));
        if (func_index>=self->func_entry->funcs->ftdb->funcs_count) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"func entry index out of bounds: %lu\n",func_index);
            PyErr_SetString(libftdb_ftdbError, errmsg);
            return 0;
        }
        self->func_index = func_index;
        unsigned long entry_index = PyLong_AsLong(PyTuple_GetItem(args,2));
        if (entry_index>=self->func_entry->funcs->ftdb->funcs[func_index].switches_count) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"switchinfo entry index out of bounds: %lu@%lu\n",func_index,entry_index);
            PyErr_SetString(libftdb_ftdbError,errmsg);
            return 0;
        }
        self->entry_index = entry_index;
        self->entry = &self->func_entry->funcs->ftdb->funcs[self->func_index].switches[self->entry_index];
    }

    return (PyObject *)self;
}

PyObject* libftdb_ftdb_func_switchinfo_entry_repr(PyObject* self) {

    static char repr[1024];

    libftdb_ftdb_func_switchinfo_entry_object* __self = (libftdb_ftdb_func_switchinfo_entry_object*)self;
    int written = snprintf(repr,1024,"<ftdbFuncSwitchInfoEntry object at %lx : ",(uintptr_t)self);
    written+=snprintf(repr+written,1024-written,"fdx:%lu|edx:%lu>",__self->func_index,__self->entry_index);

    return PyUnicode_FromString(repr);
}

PyObject* libftdb_ftdb_func_switchinfo_entry_get_condition(PyObject* self, void* closure) {

    libftdb_ftdb_func_switchinfo_entry_object* __self = (libftdb_ftdb_func_switchinfo_entry_object*)self;

    return PyUnicode_FromString(__self->entry->condition);
}

PyObject* libftdb_ftdb_func_switchinfo_entry_get_cases(PyObject* self, void* closure) {

    libftdb_ftdb_func_switchinfo_entry_object* __self = (libftdb_ftdb_func_switchinfo_entry_object*)self;

    PyObject* cases = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->cases_count; ++i) {
        struct case_info* case_info = &__self->entry->cases[i];
        if (!case_info->rhs) {
            PyObject* py_case_info = PyList_New(0);
            PYLIST_ADD_LONG(py_case_info,case_info->lhs.expr_value);
            PYLIST_ADD_STRING(py_case_info,case_info->lhs.enum_code);
            PYLIST_ADD_STRING(py_case_info,case_info->lhs.macro_code);
            PYLIST_ADD_STRING(py_case_info,case_info->lhs.raw_code);
            PyList_Append(cases,py_case_info);
            Py_DecRef(py_case_info);
        }
        else {
            PyObject* py_case_info = PyList_New(0);
            PYLIST_ADD_LONG(py_case_info,case_info->lhs.expr_value);
            PYLIST_ADD_STRING(py_case_info,case_info->lhs.enum_code);
            PYLIST_ADD_STRING(py_case_info,case_info->lhs.macro_code);
            PYLIST_ADD_STRING(py_case_info,case_info->lhs.raw_code);
            PYLIST_ADD_LONG(py_case_info,case_info->rhs->expr_value);
            PYLIST_ADD_STRING(py_case_info,case_info->rhs->enum_code);
            PYLIST_ADD_STRING(py_case_info,case_info->rhs->macro_code);
            PYLIST_ADD_STRING(py_case_info,case_info->rhs->raw_code);
            PyList_Append(cases,py_case_info);
            Py_DecRef(py_case_info);
        }
    }
    return cases;
}

PyObject* libftdb_ftdb_func_switchinfo_entry_mp_subscript(PyObject* self, PyObject* slice) {

    static char errmsg[ERRMSG_BUFFER_SIZE];

    if (!PyUnicode_Check(slice)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in property mapping (not a str)");
        Py_RETURN_NONE;
    }

    const char* attr = PyString_get_c_str(slice);

    if (!strcmp(attr,"condition")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_switchinfo_entry_get_condition(self,0);
    }
    else if (!strcmp(attr,"cases")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_switchinfo_entry_get_cases(self,0);
    }

    snprintf(errmsg,ERRMSG_BUFFER_SIZE,"Invalid attribute name: %s",attr);
    PyErr_SetString(libftdb_ftdbError, errmsg);
    PYASSTR_DECREF(attr);
    Py_RETURN_NONE;
}

int libftdb_ftdb_func_switchinfo_entry_sq_contains(PyObject* self, PyObject* key) {

    if (!PyUnicode_Check(key)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in contains check (not a str)");
        return 0;
    }

    const char* attr = PyString_get_c_str(key);

    if (!strcmp(attr,"condition")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"cases")) {
        PYASSTR_DECREF(attr);
        return 1;
    }

    PYASSTR_DECREF(attr);
    return 0;
}

PyObject* libftdb_ftdb_func_switchinfo_entry_json(libftdb_ftdb_func_switchinfo_entry_object *self, PyObject *args) {

    libftdb_ftdb_func_switchinfo_entry_object* __self = (libftdb_ftdb_func_switchinfo_entry_object*)self;
    PyObject* py_switchinfo_entry = PyDict_New();

    PyObject* cases = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->cases_count; ++i) {
        struct case_info* case_info = &__self->entry->cases[i];
        if (!case_info->rhs) {
            PyObject* py_case_info = PyList_New(0);
            PYLIST_ADD_LONG(py_case_info,case_info->lhs.expr_value);
            PYLIST_ADD_STRING(py_case_info,case_info->lhs.enum_code);
            PYLIST_ADD_STRING(py_case_info,case_info->lhs.macro_code);
            PYLIST_ADD_STRING(py_case_info,case_info->lhs.raw_code);
            PyList_Append(cases,py_case_info);
            Py_DecRef(py_case_info);
        }
        else {
            PyObject* py_case_info = PyList_New(0);
            PYLIST_ADD_LONG(py_case_info,case_info->lhs.expr_value);
            PYLIST_ADD_STRING(py_case_info,case_info->lhs.enum_code);
            PYLIST_ADD_STRING(py_case_info,case_info->lhs.macro_code);
            PYLIST_ADD_STRING(py_case_info,case_info->lhs.raw_code);
            PYLIST_ADD_LONG(py_case_info,case_info->rhs->expr_value);
            PYLIST_ADD_STRING(py_case_info,case_info->rhs->enum_code);
            PYLIST_ADD_STRING(py_case_info,case_info->rhs->macro_code);
            PYLIST_ADD_STRING(py_case_info,case_info->rhs->raw_code);
            PyList_Append(cases,py_case_info);
            Py_DecRef(py_case_info);
        }
    }

    FTDB_SET_ENTRY_PYOBJECT(py_switchinfo_entry,cases,cases);
    FTDB_SET_ENTRY_STRING(py_switchinfo_entry,condition,__self->entry->condition);

    return py_switchinfo_entry;
}

void libftdb_ftdb_func_ifinfo_entry_dealloc(libftdb_ftdb_func_ifinfo_entry_object* self) {

    Py_DecRef((PyObject*)self->func_entry);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_func_ifinfo_entry_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    static char errmsg[ERRMSG_BUFFER_SIZE];
    libftdb_ftdb_func_ifinfo_entry_object* self;

    self = (libftdb_ftdb_func_ifinfo_entry_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->func_entry = (const libftdb_ftdb_func_entry_object*)PyLong_AsLong(PyTuple_GetItem(args,0));
        Py_IncRef((PyObject*)self->func_entry);
        unsigned long func_index = PyLong_AsLong(PyTuple_GetItem(args,1));
        if (func_index>=self->func_entry->funcs->ftdb->funcs_count) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"func entry index out of bounds: %lu\n",func_index);
            PyErr_SetString(libftdb_ftdbError, errmsg);
            return 0;
        }
        self->func_index = func_index;
        unsigned long entry_index = PyLong_AsLong(PyTuple_GetItem(args,2));
        if (entry_index>=self->func_entry->funcs->ftdb->funcs[func_index].ifs_count) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"ifinfo entry index out of bounds: %lu@%lu\n",func_index,entry_index);
            PyErr_SetString(libftdb_ftdbError,errmsg);
            return 0;
        }
        self->entry_index = entry_index;
        self->entry = &self->func_entry->funcs->ftdb->funcs[self->func_index].ifs[self->entry_index];
    }

    return (PyObject *)self;
}

PyObject* libftdb_ftdb_func_ifinfo_entry_repr(PyObject* self) {

    static char repr[1024];

    libftdb_ftdb_func_ifinfo_entry_object* __self = (libftdb_ftdb_func_ifinfo_entry_object*)self;
    int written = snprintf(repr,1024,"<ftdbFuncIfInfoEntry object at %lx : ",(uintptr_t)self);
    written+=snprintf(repr+written,1024-written,"fdx:%lu|edx:%lu>",__self->func_index,__self->entry_index);

    return PyUnicode_FromString(repr);
}

PyObject* libftdb_ftdb_func_ifinfo_entry_get_csid(PyObject* self, void* closure) {

    libftdb_ftdb_func_ifinfo_entry_object* __self = (libftdb_ftdb_func_ifinfo_entry_object*)self;
    return PyLong_FromLong(__self->entry->csid);
}

PyObject* libftdb_ftdb_func_ifinfo_entry_get_refs(PyObject* self, void* closure) {

    libftdb_ftdb_func_ifinfo_entry_object* __self = (libftdb_ftdb_func_ifinfo_entry_object*)self;

    PyObject* refs = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->refs_count; ++i) {
        struct ifref_info* ifref_info = &__self->entry->refs[i];
        PyObject* py_ifref_info = PyDict_New();
        FTDB_SET_ENTRY_ENUM_TO_STRING(py_ifref_info,type,ifref_info->type,exprType);
        if (ifref_info->id) {
            FTDB_SET_ENTRY_ULONG_OPTIONAL(py_ifref_info,id,ifref_info->id);
        }
        else if (ifref_info->integer_literal) {
            FTDB_SET_ENTRY_INT64_OPTIONAL(py_ifref_info,id,ifref_info->integer_literal);
        }
        else if (ifref_info->character_literal) {
            FTDB_SET_ENTRY_UINT_OPTIONAL(py_ifref_info,id,ifref_info->character_literal);
        }
        else if (ifref_info->floating_literal) {
            FTDB_SET_ENTRY_FLOAT_OPTIONAL(py_ifref_info,id,ifref_info->floating_literal);
        }
        else if (ifref_info->string_literal) {
            FTDB_SET_ENTRY_STRING_OPTIONAL(py_ifref_info,id,ifref_info->string_literal);
        }
        PyList_Append(refs,py_ifref_info);
        Py_DecRef(py_ifref_info);
    }
    return refs;
}

PyObject* libftdb_ftdb_func_ifinfo_entry_mp_subscript(PyObject* self, PyObject* slice) {

    static char errmsg[ERRMSG_BUFFER_SIZE];

    if (!PyUnicode_Check(slice)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in property mapping (not a str)");
        Py_RETURN_NONE;
    }

    const char* attr = PyString_get_c_str(slice);

    if (!strcmp(attr,"csid")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_ifinfo_entry_get_csid(self,0);
    }
    else if (!strcmp(attr,"refs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_ifinfo_entry_get_refs(self,0);
    }

    snprintf(errmsg,ERRMSG_BUFFER_SIZE,"Invalid attribute name: %s",attr);
    PyErr_SetString(libftdb_ftdbError, errmsg);
    PYASSTR_DECREF(attr);
    Py_RETURN_NONE;
}

int libftdb_ftdb_func_ifinfo_entry_sq_contains(PyObject* self, PyObject* key) {

    if (!PyUnicode_Check(key)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in contains check (not a str)");
        return 0;
    }

    const char* attr = PyString_get_c_str(key);

    if (!strcmp(attr,"csid")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"refs")) {
        PYASSTR_DECREF(attr);
        return 1;
    }

    PYASSTR_DECREF(attr);
    return 0;
}

PyObject* libftdb_ftdb_func_ifinfo_entry_json(libftdb_ftdb_func_ifinfo_entry_object *self, PyObject *args) {

    libftdb_ftdb_func_ifinfo_entry_object* __self = (libftdb_ftdb_func_ifinfo_entry_object*)self;

    PyObject* py_ifinfo_entry = PyDict_New();

    PyObject* refs = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->refs_count; ++i) {
        struct ifref_info* ifref_info = &__self->entry->refs[i];
        PyObject* py_ifref_info = PyDict_New();
        FTDB_SET_ENTRY_ENUM_TO_STRING(py_ifref_info,type,ifref_info->type,exprType);
        if (ifref_info->id) {
            FTDB_SET_ENTRY_ULONG_OPTIONAL(py_ifref_info,id,ifref_info->id);
        }
        else if (ifref_info->integer_literal) {
            FTDB_SET_ENTRY_INT64_OPTIONAL(py_ifref_info,id,ifref_info->integer_literal);
        }
        else if (ifref_info->character_literal) {
            FTDB_SET_ENTRY_UINT_OPTIONAL(py_ifref_info,id,ifref_info->character_literal);
        }
        else if (ifref_info->floating_literal) {
            FTDB_SET_ENTRY_FLOAT_OPTIONAL(py_ifref_info,id,ifref_info->floating_literal);
        }
        else if (ifref_info->string_literal) {
            FTDB_SET_ENTRY_STRING_OPTIONAL(py_ifref_info,id,ifref_info->string_literal);
        }
        PyList_Append(refs,py_ifref_info);
        Py_DecRef(py_ifref_info);
    }

    FTDB_SET_ENTRY_PYOBJECT(py_ifinfo_entry,refs,refs);
    FTDB_SET_ENTRY_ULONG(py_ifinfo_entry,csid,__self->entry->csid);

    return py_ifinfo_entry;
}

void libftdb_ftdb_func_localinfo_entry_dealloc(libftdb_ftdb_func_localinfo_entry_object* self) {

    Py_DecRef((PyObject*)self->func_entry);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_func_localinfo_entry_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    static char errmsg[ERRMSG_BUFFER_SIZE];
    libftdb_ftdb_func_localinfo_entry_object* self;

    self = (libftdb_ftdb_func_localinfo_entry_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->func_entry = (const libftdb_ftdb_func_entry_object*)PyLong_AsLong(PyTuple_GetItem(args,0));
        Py_IncRef((PyObject*)self->func_entry);
        unsigned long func_index = PyLong_AsLong(PyTuple_GetItem(args,1));
        if (func_index>=self->func_entry->funcs->ftdb->funcs_count) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"func entry index out of bounds: %lu\n",func_index);
            PyErr_SetString(libftdb_ftdbError, errmsg);
            return 0;
        }
        self->func_index = func_index;
        unsigned long entry_index = PyLong_AsLong(PyTuple_GetItem(args,2));
        if (entry_index>=self->func_entry->funcs->ftdb->funcs[func_index].locals_count) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"localinfo entry index out of bounds: %lu@%lu\n",func_index,entry_index);
            PyErr_SetString(libftdb_ftdbError,errmsg);
            return 0;
        }
        self->entry_index = entry_index;
        self->entry = &self->func_entry->funcs->ftdb->funcs[self->func_index].locals[self->entry_index];
    }

    return (PyObject *)self;
}

PyObject* libftdb_ftdb_func_localinfo_entry_repr(PyObject* self) {

    static char repr[1024];

    libftdb_ftdb_func_localinfo_entry_object* __self = (libftdb_ftdb_func_localinfo_entry_object*)self;
    int written = snprintf(repr,1024,"<ftdbFuncLocalInfoEntry object at %lx : ",(uintptr_t)self);
    written+=snprintf(repr+written,1024-written,"fdx:%lu|edx:%lu>",__self->func_index,__self->entry_index);

    return PyUnicode_FromString(repr);
}

PyObject* libftdb_ftdb_func_localinfo_entry_get_id(PyObject* self, void* closure) {

    libftdb_ftdb_func_localinfo_entry_object* __self = (libftdb_ftdb_func_localinfo_entry_object*)self;
    return PyLong_FromUnsignedLong(__self->entry->id);
}

PyObject* libftdb_ftdb_func_localinfo_entry_get_name(PyObject* self, void* closure) {

    libftdb_ftdb_func_localinfo_entry_object* __self = (libftdb_ftdb_func_localinfo_entry_object*)self;
    return PyUnicode_FromString(__self->entry->name);
}

PyObject* libftdb_ftdb_func_localinfo_entry_is_parm(PyObject* self, void* closure) {

    libftdb_ftdb_func_localinfo_entry_object* __self = (libftdb_ftdb_func_localinfo_entry_object*)self;

    if (__self->entry->isparm) {
        Py_RETURN_TRUE;
    }
    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_func_localinfo_entry_get_type(PyObject* self, void* closure) {

    libftdb_ftdb_func_localinfo_entry_object* __self = (libftdb_ftdb_func_localinfo_entry_object*)self;
    return PyLong_FromUnsignedLong(__self->entry->type);
}

PyObject* libftdb_ftdb_func_localinfo_entry_is_static(PyObject* self, void* closure) {

    libftdb_ftdb_func_localinfo_entry_object* __self = (libftdb_ftdb_func_localinfo_entry_object*)self;

    if (__self->entry->isstatic) {
        Py_RETURN_TRUE;
    }
    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_func_localinfo_entry_is_used(PyObject* self, void* closure) {

    libftdb_ftdb_func_localinfo_entry_object* __self = (libftdb_ftdb_func_localinfo_entry_object*)self;

    if (__self->entry->isused) {
        Py_RETURN_TRUE;
    }
    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_func_localinfo_entry_get_csid(PyObject* self, void* closure) {

    libftdb_ftdb_func_localinfo_entry_object* __self = (libftdb_ftdb_func_localinfo_entry_object*)self;
    if (!__self->entry->csid) {
        PyErr_SetString(libftdb_ftdbError, "No 'csid' field in localinfo entry");
        return 0;
    }
    return PyLong_FromUnsignedLong(*__self->entry->csid);
}

PyObject* libftdb_ftdb_func_localinfo_entry_get_location(PyObject* self, void* closure) {

    libftdb_ftdb_func_localinfo_entry_object* __self = (libftdb_ftdb_func_localinfo_entry_object*)self;
    return PyUnicode_FromString(__self->entry->location);
}

PyObject* libftdb_ftdb_func_localinfo_entry_has_csid(libftdb_ftdb_func_entry_object *self, PyObject *args) {

    libftdb_ftdb_func_localinfo_entry_object* __self = (libftdb_ftdb_func_localinfo_entry_object*)self;

    if (__self->entry->csid) {
        Py_RETURN_TRUE;
    }
    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_func_localinfo_entry_mp_subscript(PyObject* self, PyObject* slice) {

    static char errmsg[ERRMSG_BUFFER_SIZE];

    if (!PyUnicode_Check(slice)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in property mapping (not a str)");
        Py_RETURN_NONE;
    }

    const char* attr = PyString_get_c_str(slice);

    if (!strcmp(attr,"id")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_localinfo_entry_get_id(self,0);
    }
    else if (!strcmp(attr,"name")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_localinfo_entry_get_name(self,0);
    }
    else if (!strcmp(attr,"parm")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_localinfo_entry_is_parm(self,0);
    }
    else if (!strcmp(attr,"type")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_localinfo_entry_get_type(self,0);
    }
    else if (!strcmp(attr,"static")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_localinfo_entry_is_static(self,0);
    }
    else if (!strcmp(attr,"used")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_localinfo_entry_is_used(self,0);
    }
    else if (!strcmp(attr,"csid")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_localinfo_entry_get_csid(self,0);
    }
    else if (!strcmp(attr,"location")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_localinfo_entry_get_location(self,0);
    }

    snprintf(errmsg,ERRMSG_BUFFER_SIZE,"Invalid attribute name: %s",attr);
    PyErr_SetString(libftdb_ftdbError, errmsg);
    PYASSTR_DECREF(attr);
    Py_RETURN_NONE;
}

int libftdb_ftdb_func_localinfo_entry_sq_contains(PyObject* self, PyObject* key) {

    if (!PyUnicode_Check(key)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in contains check (not a str)");
        return 0;
    }

    libftdb_ftdb_func_localinfo_entry_object* __self = (libftdb_ftdb_func_localinfo_entry_object*)self;
    const char* attr = PyString_get_c_str(key);

    if (!strcmp(attr,"id")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"name")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"parm")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"type")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"static")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"used")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"csid")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->csid;
    }
    else if (!strcmp(attr,"location")) {
        PYASSTR_DECREF(attr);
        return 1;
    }

    PYASSTR_DECREF(attr);
    return 0;
}

PyObject* libftdb_ftdb_func_localinfo_entry_json(libftdb_ftdb_func_localinfo_entry_object *self, PyObject *args) {

    libftdb_ftdb_func_localinfo_entry_object* __self = (libftdb_ftdb_func_localinfo_entry_object*)self;

    PyObject* py_localinfo_entry = PyDict_New();

    FTDB_SET_ENTRY_ULONG(py_localinfo_entry,id,__self->entry->id);
    FTDB_SET_ENTRY_STRING(py_localinfo_entry,name,__self->entry->name);
    FTDB_SET_ENTRY_BOOL(py_localinfo_entry,parm,__self->entry->isparm);
    FTDB_SET_ENTRY_ULONG(py_localinfo_entry,type,__self->entry->type);
    FTDB_SET_ENTRY_BOOL(py_localinfo_entry,static,__self->entry->isstatic);
    FTDB_SET_ENTRY_BOOL(py_localinfo_entry,used,__self->entry->isused);
    FTDB_SET_ENTRY_ULONG_OPTIONAL(py_localinfo_entry,csid,__self->entry->csid);
    FTDB_SET_ENTRY_STRING(py_localinfo_entry,location,__self->entry->location);

    return py_localinfo_entry;
}

void libftdb_ftdb_func_derefinfo_entry_dealloc(libftdb_ftdb_func_derefinfo_entry_object* self) {

    Py_DecRef((PyObject*)self->func_entry);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_func_derefinfo_entry_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    static char errmsg[ERRMSG_BUFFER_SIZE];
    libftdb_ftdb_func_derefinfo_entry_object* self;

    self = (libftdb_ftdb_func_derefinfo_entry_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->func_entry = (const libftdb_ftdb_func_entry_object*)PyLong_AsLong(PyTuple_GetItem(args,0));
        Py_IncRef((PyObject*)self->func_entry);
        unsigned long func_index = PyLong_AsLong(PyTuple_GetItem(args,1));
        if (func_index>=self->func_entry->funcs->ftdb->funcs_count) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"func entry index out of bounds: %lu\n",func_index);
            PyErr_SetString(libftdb_ftdbError, errmsg);
            return 0;
        }
        self->func_index = func_index;
        unsigned long entry_index = PyLong_AsLong(PyTuple_GetItem(args,2));
        if (entry_index>=self->func_entry->funcs->ftdb->funcs[func_index].derefs_count) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"derefinfo entry index out of bounds: %lu@%lu\n",func_index,entry_index);
            PyErr_SetString(libftdb_ftdbError,errmsg);
            return 0;
        }
        self->entry_index = entry_index;
        self->entry = &self->func_entry->funcs->ftdb->funcs[self->func_index].derefs[self->entry_index];
    }

    return (PyObject *)self;
}

PyObject* libftdb_ftdb_func_derefinfo_entry_repr(PyObject* self) {

    static char repr[1024];

    libftdb_ftdb_func_derefinfo_entry_object* __self = (libftdb_ftdb_func_derefinfo_entry_object*)self;
    int written = snprintf(repr,1024,"<ftdbFuncDerefInfoEntry object at %lx : ",(uintptr_t)self);
    written+=snprintf(repr+written,1024-written,"fdx:%lu|edx:%lu>",__self->func_index,__self->entry_index);

    return PyUnicode_FromString(repr);
}

PyObject* libftdb_ftdb_func_derefinfo_entry_get_kind(PyObject* self, void* closure) {

    libftdb_ftdb_func_derefinfo_entry_object* __self = (libftdb_ftdb_func_derefinfo_entry_object*)self;
    return PyLong_FromLong((long)__self->entry->kind);
}

PyObject* libftdb_ftdb_func_derefinfo_entry_get_kindname(PyObject* self, void* closure) {

    libftdb_ftdb_func_derefinfo_entry_object* __self = (libftdb_ftdb_func_derefinfo_entry_object*)self;
    return PyUnicode_FromString(set_exprType(__self->entry->kind));
}

PyObject* libftdb_ftdb_func_derefinfo_entry_get_offset(PyObject* self, void* closure) {

    libftdb_ftdb_func_derefinfo_entry_object* __self = (libftdb_ftdb_func_derefinfo_entry_object*)self;

    if (!__self->entry->offset) {
        PyErr_SetString(libftdb_ftdbError, "No 'offset' field in derefinfo entry");
        return 0;
    }
    return PyLong_FromLong(*__self->entry->offset);
}

PyObject* libftdb_ftdb_func_derefinfo_entry_get_basecnt(PyObject* self, void* closure) {

    libftdb_ftdb_func_derefinfo_entry_object* __self = (libftdb_ftdb_func_derefinfo_entry_object*)self;

    if (!__self->entry->basecnt) {
        PyErr_SetString(libftdb_ftdbError, "No 'basecnt' field in derefinfo entry");
        return 0;
    }
    return PyLong_FromUnsignedLong(*__self->entry->basecnt);
}

PyObject* libftdb_ftdb_func_derefinfo_entry_get_offsetrefs(PyObject* self, void* closure) {

    libftdb_ftdb_func_derefinfo_entry_object* __self = (libftdb_ftdb_func_derefinfo_entry_object*)self;

    PyObject* offsetrefs = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->offsetrefs_count; ++i) {
        PyObject* args = PyTuple_New(4);
        PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
        PYTUPLE_SET_ULONG(args,1,i);
        PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncOffsetrefInfoEntryType, args);
        Py_DecRef(args);
        PyList_Append(offsetrefs,entry);
        Py_DecRef(entry);
    }
    return offsetrefs;
}

PyObject* libftdb_ftdb_func_derefinfo_entry_get_expr(PyObject* self, void* closure) {

    libftdb_ftdb_func_derefinfo_entry_object* __self = (libftdb_ftdb_func_derefinfo_entry_object*)self;
    return PyUnicode_FromString(__self->entry->expr);
}

PyObject* libftdb_ftdb_func_derefinfo_entry_get_csid(PyObject* self, void* closure) {

    libftdb_ftdb_func_derefinfo_entry_object* __self = (libftdb_ftdb_func_derefinfo_entry_object*)self;
    return PyLong_FromLong(__self->entry->csid);
}

PyObject* libftdb_ftdb_func_derefinfo_entry_get_ords(PyObject* self, void* closure) {

    libftdb_ftdb_func_derefinfo_entry_object* __self = (libftdb_ftdb_func_derefinfo_entry_object*)self;

    PyObject* ords = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->ord_count; ++i) {
        PYLIST_ADD_ULONG(ords,__self->entry->ord[i]);
    }
    return ords;
}

PyObject* libftdb_ftdb_func_derefinfo_entry_get_member(PyObject* self, void* closure) {

    libftdb_ftdb_func_derefinfo_entry_object* __self = (libftdb_ftdb_func_derefinfo_entry_object*)self;

    if (!__self->entry->member) {
        PyErr_SetString(libftdb_ftdbError, "No 'member' field in derefinfo entry");
        return 0;
    }

    PyObject* member = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->member_count; ++i) {
        PYLIST_ADD_LONG(member,__self->entry->member[i]);
    }
    return member;
}

PyObject* libftdb_ftdb_func_derefinfo_entry_get_type(PyObject* self, void* closure) {

    libftdb_ftdb_func_derefinfo_entry_object* __self = (libftdb_ftdb_func_derefinfo_entry_object*)self;

    if (!__self->entry->type) {
        PyErr_SetString(libftdb_ftdbError, "No 'type' field in derefinfo entry");
        return 0;
    }

    PyObject* type = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->type_count; ++i) {
        PYLIST_ADD_ULONG(type,__self->entry->type[i]);
    }
    return type;
}

PyObject* libftdb_ftdb_func_derefinfo_entry_get_access(PyObject* self, void* closure) {

    libftdb_ftdb_func_derefinfo_entry_object* __self = (libftdb_ftdb_func_derefinfo_entry_object*)self;

    if (!__self->entry->access) {
        PyErr_SetString(libftdb_ftdbError, "No 'access' field in derefinfo entry");
        return 0;
    }

    PyObject* access = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->access_count; ++i) {
        PYLIST_ADD_ULONG(access,__self->entry->access[i]);
    }
    return access;
}

PyObject* libftdb_ftdb_func_derefinfo_entry_get_shift(PyObject* self, void* closure) {

    libftdb_ftdb_func_derefinfo_entry_object* __self = (libftdb_ftdb_func_derefinfo_entry_object*)self;

    if (!__self->entry->shift) {
        PyErr_SetString(libftdb_ftdbError, "No 'shift' field in derefinfo entry");
        return 0;
    }

    PyObject* shift = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->shift_count; ++i) {
        PYLIST_ADD_LONG(shift,__self->entry->shift[i]);
    }
    return shift;
}

PyObject* libftdb_ftdb_func_derefinfo_entry_get_mcall(PyObject* self, void* closure) {

    libftdb_ftdb_func_derefinfo_entry_object* __self = (libftdb_ftdb_func_derefinfo_entry_object*)self;

    if (!__self->entry->mcall) {
        PyErr_SetString(libftdb_ftdbError, "No 'mcall' field in derefinfo entry");
        return 0;
    }

    PyObject* mcall = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->mcall_count; ++i) {
        PYLIST_ADD_LONG(mcall,__self->entry->mcall[i]);
    }
    return mcall;
}

PyObject* libftdb_ftdb_func_derefinfo_entry_json(libftdb_ftdb_func_derefinfo_entry_object *self, PyObject *args) {

    PyObject* py_deref_entry = PyDict_New();

    FTDB_SET_ENTRY_ENUM_TO_STRING(py_deref_entry,kind,self->entry->kind,exprType);
    FTDB_SET_ENTRY_INT64_OPTIONAL(py_deref_entry,offset,self->entry->offset);
    FTDB_SET_ENTRY_ULONG_OPTIONAL(py_deref_entry,basecnt,self->entry->basecnt);
    PyObject* offsetrefs = PyList_New(0);
    for (unsigned long j=0; j<self->entry->offsetrefs_count; ++j) {
        struct offsetref_info* offsetref_info = &self->entry->offsetrefs[j];
        PyObject* py_offsetref_entry = PyDict_New();
        FTDB_SET_ENTRY_ENUM_TO_STRING(py_offsetref_entry,kind,offsetref_info->kind,exprType);
        if (offsetref_info->kind==EXPR_STRING) {
            FTDB_SET_ENTRY_STRING(py_offsetref_entry,id,offsetref_info->id_string);
        }
        else if (offsetref_info->kind==EXPR_FLOATING) {
            FTDB_SET_ENTRY_FLOAT(py_offsetref_entry,id,offsetref_info->id_float);
        }
        else {
            FTDB_SET_ENTRY_INT64(py_offsetref_entry,id,offsetref_info->id_integer);
        }
        FTDB_SET_ENTRY_ULONG_OPTIONAL(py_offsetref_entry,mi,offsetref_info->mi);
        FTDB_SET_ENTRY_ULONG_OPTIONAL(py_offsetref_entry,di,offsetref_info->di);
        FTDB_SET_ENTRY_ULONG_OPTIONAL(py_offsetref_entry,cast,offsetref_info->cast);
        PYLIST_ADD_PYOBJECT(offsetrefs,py_offsetref_entry);
    }
    FTDB_SET_ENTRY_PYOBJECT(py_deref_entry,offsetrefs,offsetrefs);
    FTDB_SET_ENTRY_STRING(py_deref_entry,expr,self->entry->expr);
    FTDB_SET_ENTRY_INT64(py_deref_entry,csid,self->entry->csid);
    FTDB_SET_ENTRY_ULONG_ARRAY(py_deref_entry,ord,self->entry->ord);
    FTDB_SET_ENTRY_INT64_ARRAY_OPTIONAL(py_deref_entry,member,self->entry->member);
    FTDB_SET_ENTRY_ULONG_ARRAY_OPTIONAL(py_deref_entry,type,self->entry->type);
    FTDB_SET_ENTRY_ULONG_ARRAY_OPTIONAL(py_deref_entry,access,self->entry->access);
    FTDB_SET_ENTRY_INT64_ARRAY_OPTIONAL(py_deref_entry,shift,self->entry->shift);
    FTDB_SET_ENTRY_INT64_ARRAY_OPTIONAL(py_deref_entry,mcall,self->entry->mcall);

    return py_deref_entry;
}

PyObject* libftdb_ftdb_func_derefinfo_entry_mp_subscript(PyObject* self, PyObject* slice) {

    static char errmsg[ERRMSG_BUFFER_SIZE];

    if (!PyUnicode_Check(slice)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in property mapping (not a str)");
        Py_RETURN_NONE;
    }

    const char* attr = PyString_get_c_str(slice);

    if (!strcmp(attr,"kind")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_derefinfo_entry_get_kindname(self,0);
    }
    else if (!strcmp(attr,"offset")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_derefinfo_entry_get_offset(self,0);
    }
    else if (!strcmp(attr,"basecnt")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_derefinfo_entry_get_basecnt(self,0);
    }
    else if (!strcmp(attr,"offsetrefs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_derefinfo_entry_get_offsetrefs(self,0);
    }
    else if (!strcmp(attr,"expr")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_derefinfo_entry_get_expr(self,0);
    }
    else if (!strcmp(attr,"csid")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_derefinfo_entry_get_csid(self,0);
    }
    else if (!strcmp(attr,"ord")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_derefinfo_entry_get_ords(self,0);
    }
    else if (!strcmp(attr,"member")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_derefinfo_entry_get_member(self,0);
    }
    else if (!strcmp(attr,"type")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_derefinfo_entry_get_type(self,0);
    }
    else if (!strcmp(attr,"access")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_derefinfo_entry_get_access(self,0);
    }
    else if (!strcmp(attr,"shift")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_derefinfo_entry_get_shift(self,0);
    }
    else if (!strcmp(attr,"mcall")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_derefinfo_entry_get_mcall(self,0);
    }

    snprintf(errmsg,ERRMSG_BUFFER_SIZE,"Invalid attribute name: %s",attr);
    PyErr_SetString(libftdb_ftdbError, errmsg);
    PYASSTR_DECREF(attr);
    Py_RETURN_NONE;
}

int libftdb_ftdb_func_derefinfo_entry_sq_contains(PyObject* self, PyObject* key) {

    if (!PyUnicode_Check(key)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in contains check (not a str)");
        return 0;
    }

    libftdb_ftdb_func_derefinfo_entry_object* __self = (libftdb_ftdb_func_derefinfo_entry_object*)self;
    const char* attr = PyString_get_c_str(key);

    if (!strcmp(attr,"kind")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"offset")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->offset;
    }
    else if (!strcmp(attr,"basecnt")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->basecnt;
    }
    else if (!strcmp(attr,"offsetrefs")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"expr")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"csid")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"ord")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"member")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->member;
    }
    else if (!strcmp(attr,"type")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->type;
    }
    else if (!strcmp(attr,"access")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->access;
    }
    else if (!strcmp(attr,"shift")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->shift;
    }
    else if (!strcmp(attr,"mcall")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->mcall;
    }

    PYASSTR_DECREF(attr);
    return 0;
}

void libftdb_ftdb_func_offsetrefinfo_entry_dealloc(libftdb_ftdb_func_offsetrefinfo_entry_object* self) {

    Py_DecRef((PyObject*)self->deref_entry);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_func_offsetrefinfo_entry_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    libftdb_ftdb_func_offsetrefinfo_entry_object* self;

    self = (libftdb_ftdb_func_offsetrefinfo_entry_object*)subtype->tp_alloc(subtype, 0);
    if (self == NULL)
        return NULL;

    self->deref_entry = (const libftdb_ftdb_func_derefinfo_entry_object*)PyLong_AsLong(PyTuple_GetItem(args,0));
    Py_IncRef((PyObject*)self->deref_entry);
    
    unsigned long entry_index = PyLong_AsLong(PyTuple_GetItem(args,1));
    if (entry_index >= self->deref_entry->entry->offsetrefs_count)
        return PyErr_Format(libftdb_ftdbError, "offsetrefinfo entry index out of bounds: %lu", entry_index);
    
    self->entry_index = entry_index;
    self->entry = &self->deref_entry->entry->offsetrefs[self->entry_index];
    return (PyObject *)self;
}

PyObject* libftdb_ftdb_func_offsetrefinfo_entry_repr(PyObject* self) {

    libftdb_ftdb_func_offsetrefinfo_entry_object* __self = (libftdb_ftdb_func_offsetrefinfo_entry_object*) self;
    return PyUnicode_FromFormat("<ftdbFuncOffsetrefInfoEntry object at %p : fdx:%lu|ddx:%lu|edx:%lu>",
            self, __self->deref_entry->func_entry->index, __self->deref_entry->entry_index, __self->entry_index);

}

PyObject* libftdb_ftdb_func_offsetrefinfo_entry_richcompare(PyObject *self, PyObject *other, int op) {
    bool equals = true;
    PyObject *self_id, *other_id;
    libftdb_ftdb_func_offsetrefinfo_entry_object* __self = (libftdb_ftdb_func_offsetrefinfo_entry_object*)self;
    libftdb_ftdb_func_offsetrefinfo_entry_object* __other = (libftdb_ftdb_func_offsetrefinfo_entry_object*)other;
    
    if (op != Py_EQ && op != Py_NE)
        Py_RETURN_NOTIMPLEMENTED;

    if (!PyObject_IsInstance(other, (PyObject *)&libftdb_ftdbFuncOffsetrefInfoEntryType))
        Py_RETURN_FALSE;
    
    if (__self->entry->kind != __other->entry->kind) {
        equals = false;
        goto out;
    }

    if(!SAFE_OPTIONAL_COMPARE(__self->entry->mi, __other->entry->mi))
        equals = false;
    if(!SAFE_OPTIONAL_COMPARE(__self->entry->di, __other->entry->di))
        equals = false;
    if(!SAFE_OPTIONAL_COMPARE(__self->entry->cast, __other->entry->cast))
        equals = false;

    // Comapare IDs
    self_id = libftdb_ftdb_func_offsetrefinfo_entry_get_id((PyObject*) __self, NULL);
    other_id = libftdb_ftdb_func_offsetrefinfo_entry_get_id((PyObject*) __other, NULL);
    if(!PyObject_RichCompareBool(self_id, other_id, Py_EQ))
        equals = false;
    Py_DecRef(self_id);
    Py_DecRef(other_id);

out:
    if((op == Py_EQ && equals) || (op == Py_NE && !equals))
        Py_RETURN_TRUE;
    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_func_offsetrefinfo_entry_get_kind(PyObject* self, void* closure) {

    libftdb_ftdb_func_offsetrefinfo_entry_object* __self = (libftdb_ftdb_func_offsetrefinfo_entry_object*)self;
    return PyLong_FromLong((long)__self->entry->kind);
}

PyObject* libftdb_ftdb_func_offsetrefinfo_entry_get_kindname(PyObject* self, void* closure) {

    libftdb_ftdb_func_offsetrefinfo_entry_object* __self = (libftdb_ftdb_func_offsetrefinfo_entry_object*)self;
    return PyUnicode_FromString(set_exprType(__self->entry->kind));
}

PyObject* libftdb_ftdb_func_offsetrefinfo_entry_get_id(PyObject* self, void* closure) {

    libftdb_ftdb_func_offsetrefinfo_entry_object* __self = (libftdb_ftdb_func_offsetrefinfo_entry_object*)self;
    if (__self->entry->kind==EXPR_STRING) {
        return PyUnicode_FromString(__self->entry->id_string);
    }
    else if (__self->entry->kind==EXPR_FLOATING) {
        return PyFloat_FromDouble(__self->entry->id_float);
    }
    else {
        return PyLong_FromLong(__self->entry->id_integer);
    }
}

PyObject* libftdb_ftdb_func_offsetrefinfo_entry_get_mi(PyObject* self, void* closure) {

    libftdb_ftdb_func_offsetrefinfo_entry_object* __self = (libftdb_ftdb_func_offsetrefinfo_entry_object*)self;

    if (!__self->entry->mi) {
        PyErr_SetString(libftdb_ftdbError, "No 'mi' field in offsetrefinfo entry");
        return 0;
    }
    return PyLong_FromUnsignedLong(*__self->entry->mi);
}

PyObject* libftdb_ftdb_func_offsetrefinfo_entry_get_di(PyObject* self, void* closure) {

    libftdb_ftdb_func_offsetrefinfo_entry_object* __self = (libftdb_ftdb_func_offsetrefinfo_entry_object*)self;

    if (!__self->entry->di) {
        PyErr_SetString(libftdb_ftdbError, "No 'di' field in offsetrefinfo entry");
        return 0;
    }
    return PyLong_FromUnsignedLong(*__self->entry->di);
}

PyObject* libftdb_ftdb_func_offsetrefinfo_entry_get_cast(PyObject* self, void* closure) {

    libftdb_ftdb_func_offsetrefinfo_entry_object* __self = (libftdb_ftdb_func_offsetrefinfo_entry_object*)self;

    if (!__self->entry->cast) {
        PyErr_SetString(libftdb_ftdbError, "No 'cast' field in offsetrefinfo entry");
        return 0;
    }
    return PyLong_FromUnsignedLong(*__self->entry->cast);
}

PyObject* libftdb_ftdb_func_offsetrefinfo_entry_has_cast(libftdb_ftdb_func_offsetrefinfo_entry_object *self, PyObject *args) {

    if (self->entry->cast) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_func_offsetrefinfo_entry_json(libftdb_ftdb_func_offsetrefinfo_entry_object *self, PyObject *args) {

    PyObject* py_offsetref_entry = PyDict_New();

    struct offsetref_info* offsetref_info = self->entry;
    FTDB_SET_ENTRY_ENUM_TO_STRING(py_offsetref_entry,kind,offsetref_info->kind,exprType);
    if (offsetref_info->kind==EXPR_STRING) {
        FTDB_SET_ENTRY_STRING(py_offsetref_entry,id,offsetref_info->id_string);
    }
    else if (offsetref_info->kind==EXPR_FLOATING) {
        FTDB_SET_ENTRY_FLOAT(py_offsetref_entry,id,offsetref_info->id_float);
    }
    else {
        FTDB_SET_ENTRY_INT64(py_offsetref_entry,id,offsetref_info->id_integer);
    }
    FTDB_SET_ENTRY_ULONG_OPTIONAL(py_offsetref_entry,mi,offsetref_info->mi);
    FTDB_SET_ENTRY_ULONG_OPTIONAL(py_offsetref_entry,di,offsetref_info->di);
    FTDB_SET_ENTRY_ULONG_OPTIONAL(py_offsetref_entry,cast,offsetref_info->cast);

    return py_offsetref_entry;
}

PyObject* libftdb_ftdb_func_offsetrefinfo_entry_mp_subscript(PyObject* self, PyObject* slice) {

    static char errmsg[ERRMSG_BUFFER_SIZE];

    if (!PyUnicode_Check(slice)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in property mapping (not a str)");
        Py_RETURN_NONE;
    }

    const char* attr = PyString_get_c_str(slice);

    if (!strcmp(attr,"kind")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_offsetrefinfo_entry_get_kindname(self,0);
    }
    else if (!strcmp(attr,"id")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_offsetrefinfo_entry_get_id(self,0);
    }
    else if (!strcmp(attr,"mi")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_offsetrefinfo_entry_get_mi(self,0);
    }
    else if (!strcmp(attr,"di")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_offsetrefinfo_entry_get_di(self,0);
    }
    else if (!strcmp(attr,"cast")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_func_offsetrefinfo_entry_get_cast(self,0);
    }

    snprintf(errmsg,ERRMSG_BUFFER_SIZE,"Invalid attribute name: %s",attr);
    PyErr_SetString(libftdb_ftdbError, errmsg);
    PYASSTR_DECREF(attr);
    Py_RETURN_NONE;
}

int libftdb_ftdb_func_offsetrefinfo_entry_sq_contains(PyObject* self, PyObject* key) {

    if (!PyUnicode_Check(key)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in contains check (not a str)");
        return 0;
    }

    libftdb_ftdb_func_offsetrefinfo_entry_object* __self = (libftdb_ftdb_func_offsetrefinfo_entry_object*)self;
    const char* attr = PyString_get_c_str(key);

    if (!strcmp(attr,"kind")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"id")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"mi")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->mi;
    }
    else if (!strcmp(attr,"di")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->di;
    }
    else if (!strcmp(attr,"cast")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->cast;
    }

    PYASSTR_DECREF(attr);
    return 0;
}

void libftdb_ftdb_funcdecls_dealloc(libftdb_ftdb_funcdecls_object* self) {

    Py_DecRef((PyObject*)self->py_ftdb);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_funcdecls_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    libftdb_ftdb_funcdecls_object* self;

    self = (libftdb_ftdb_funcdecls_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->ftdb = (const struct ftdb*)PyLong_AsLong(PyTuple_GetItem(args,0));
        self->py_ftdb = (const libftdb_ftdb_object*)PyLong_AsLong(PyTuple_GetItem(args,1));
        Py_IncRef((PyObject*)self->py_ftdb);
    }

    return (PyObject *)self;
}

PyObject* libftdb_ftdb_funcdecls_repr(PyObject* self) {

    static char repr[1024];

    libftdb_ftdb_funcdecls_object* __self = (libftdb_ftdb_funcdecls_object*)self;
    int written = snprintf(repr,1024,"<ftdbFuncdecls object at %lx : ",(uintptr_t)self);
    written+=snprintf(repr+written,1024-written,"%ld funcdecls>",__self->ftdb->funcdecls_count);

    return PyUnicode_FromString(repr);
}

Py_ssize_t libftdb_ftdb_funcdecls_sq_length(PyObject* self) {

    libftdb_ftdb_funcdecls_object* __self = (libftdb_ftdb_funcdecls_object*)self;
    return __self->ftdb->funcdecls_count;
}

PyObject* libftdb_ftdb_funcdecls_getiter(PyObject* self) {

    libftdb_ftdb_funcdecls_object* __self = (libftdb_ftdb_funcdecls_object*)self;

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
    PYTUPLE_SET_ULONG(args,1,0);
    PyObject *iter = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncdeclsIterType, args);
    Py_DecRef(args);
    return iter;
}

void libftdb_ftdb_funcdecls_iter_dealloc(libftdb_ftdb_funcdecls_iter_object* self) {

    Py_DecRef((PyObject*)self->funcdecls);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_funcdecls_iter_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    libftdb_ftdb_funcdecls_iter_object* self;

    self = (libftdb_ftdb_funcdecls_iter_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->funcdecls = (libftdb_ftdb_funcdecls_object*)PyLong_AsLong(PyTuple_GetItem(args,0));
        Py_IncRef((PyObject*)self->funcdecls);
        self->index = PyLong_AsLong(PyTuple_GetItem(args,1));
    }

    return (PyObject *)self;
}

Py_ssize_t libftdb_ftdb_funcdecls_iter_sq_length(PyObject* self) {

    libftdb_ftdb_funcdecls_iter_object* __self = (libftdb_ftdb_funcdecls_iter_object*)self;
    return __self->funcdecls->ftdb->funcdecls_count;
}

PyObject* libftdb_ftdb_funcdecls_iter_next(PyObject *self) {

    libftdb_ftdb_funcdecls_iter_object* __self = (libftdb_ftdb_funcdecls_iter_object*)self;

    if (__self->index >= __self->funcdecls->ftdb->funcdecls_count) {
        /* Raising of standard StopIteration exception with empty value. */
        PyErr_SetNone(PyExc_StopIteration);
        return 0;
    }

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self->funcdecls);
    PYTUPLE_SET_ULONG(args,1,__self->index);
    PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncdeclsEntryType, args);
    Py_DecRef(args);
    __self->index++;
    return entry;
}

PyObject* libftdb_ftdb_funcdecls_mp_subscript(PyObject* self, PyObject* slice) {

    static char errmsg[ERRMSG_BUFFER_SIZE];
    libftdb_ftdb_funcdecls_object* __self = (libftdb_ftdb_funcdecls_object*)self;

    if (PyLong_Check(slice)) {
        unsigned long id = PyLong_AsUnsignedLong(slice);
        struct ulong_entryMap_node* node = ulong_entryMap_search(&__self->ftdb->fdrefmap, id);
        if (!node) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"invalid function decl id not present in the array: %lu\n",id);
            PyErr_SetString(libftdb_ftdbError, errmsg);
            return 0;
        }
        struct ftdb_funcdecl_entry* func_entry = (struct ftdb_funcdecl_entry*)node->entry;
        PyObject* args = PyTuple_New(2);
        PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
        PYTUPLE_SET_ULONG(args,1,func_entry->__index);
        PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncdeclsEntryType, args);
        Py_DecRef(args);
        return entry;
    }
    else if (PyUnicode_Check(slice)) {
        const char* hash = PyString_get_c_str(slice);
        struct stringRef_entryMap_node* node = stringRef_entryMap_search(&__self->ftdb->fdhrefmap, hash);
        if (!node) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"invalid function decl hash not present in the array: %s\n",hash);
            PYASSTR_DECREF(hash);
            PyErr_SetString(libftdb_ftdbError, errmsg);
            return 0;
        }
        PYASSTR_DECREF(hash);
        struct ftdb_funcdecl_entry* func_entry = (struct ftdb_funcdecl_entry*)node->entry;
        PyObject* args = PyTuple_New(2);
        PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
        PYTUPLE_SET_ULONG(args,1,func_entry->__index);
        PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncdeclsEntryType, args);
        Py_DecRef(args);
        return entry;
    }
    else {
        PyErr_SetString(libftdb_ftdbError, "Invalid subscript argument");
        return 0;
    }
}

PyObject* libftdb_ftdb_funcdecls_entry_by_id(libftdb_ftdb_funcdecls_object *self, PyObject *args) {

    unsigned long id;
    if(!PyArg_ParseTuple(args, "k", &id))
        return NULL;

    static char errmsg[ERRMSG_BUFFER_SIZE];

    struct ulong_entryMap_node* node = ulong_entryMap_search(&self->ftdb->fdrefmap, id);
    if (!node) {
        snprintf(errmsg,ERRMSG_BUFFER_SIZE,"invalid function decl id not present in the array: %lu\n",id);
        PyErr_SetString(libftdb_ftdbError, errmsg);
        return 0;
    }
    struct ftdb_funcdecl_entry* func_entry = (struct ftdb_funcdecl_entry*)node->entry;
    PyObject* _args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(_args,0,(uintptr_t)self);
    PYTUPLE_SET_ULONG(_args,1,func_entry->__index);
    PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncdeclsEntryType, _args);
    Py_DecRef(_args);
    return entry;
}

static PyObject* libftdb_ftdb_funcdecls_contains_id_internal(libftdb_ftdb_funcdecls_object *self, unsigned long id) {

    struct ulong_entryMap_node* node = ulong_entryMap_search(&self->ftdb->fdrefmap, id);
    if (node) {
        Py_RETURN_TRUE;
    }
    else {
        Py_RETURN_FALSE;
    }
}

PyObject* libftdb_ftdb_funcdecls_contains_id(libftdb_ftdb_funcdecls_object *self, PyObject *args) {

    unsigned long id;
    if(!PyArg_ParseTuple(args, "k", &id))
        return NULL;
    return libftdb_ftdb_funcdecls_contains_id_internal(self,id);
}

PyObject* libftdb_ftdb_funcdecls_entry_by_hash(libftdb_ftdb_funcdecls_object *self, PyObject *args) {

    const char* hash;
    if(!PyArg_ParseTuple(args, "s", &hash))
        return NULL;

    static char errmsg[ERRMSG_BUFFER_SIZE];
    struct stringRef_entryMap_node* node = stringRef_entryMap_search(&self->ftdb->fdhrefmap, hash);
    if (!node) {
        snprintf(errmsg,ERRMSG_BUFFER_SIZE,"invalid function decl hash not present in the array: %s\n",hash);
        PyErr_SetString(libftdb_ftdbError, errmsg);
        return 0;
    }
    struct ftdb_funcdecl_entry* funcdecl_entry = (struct ftdb_funcdecl_entry*)node->entry;
    PyObject* _args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(_args,0,(uintptr_t)self);
    PYTUPLE_SET_ULONG(_args,1,funcdecl_entry->__index);
    PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncdeclsEntryType, _args);
    Py_DecRef(_args);
    return entry;
}

static PyObject* libftdb_ftdb_funcdecls_contains_hash_internal(libftdb_ftdb_funcdecls_object *self, const char *hash) {

    struct stringRef_entryMap_node* node = stringRef_entryMap_search(&self->ftdb->fdhrefmap, hash);
    if (node) {
        Py_RETURN_TRUE;
    }
    else {
        Py_RETURN_FALSE;
    }
}

PyObject* libftdb_ftdb_funcdecls_contains_hash(libftdb_ftdb_funcdecls_object *self, PyObject *args) {

    const char* hash;
    if(!PyArg_ParseTuple(args, "s", &hash))
        return NULL;

    return libftdb_ftdb_funcdecls_contains_hash_internal(self,hash);
}

PyObject* libftdb_ftdb_funcdecls_entry_by_name(libftdb_ftdb_funcdecls_object *self, PyObject *args) {

    const char* name;
    if(!PyArg_ParseTuple(args, "s", &name))
        return NULL;

    static char errmsg[ERRMSG_BUFFER_SIZE];

    struct stringRef_entryListMap_node* node = stringRef_entryListMap_search(&self->ftdb->fdnrefmap, name);
    if (!node) {
        snprintf(errmsg,ERRMSG_BUFFER_SIZE,"invalid function declaration name not present in the array: %s\n",name);
        PyErr_SetString(libftdb_ftdbError, errmsg);
        return 0;
    }
    struct ftdb_funcdecl_entry** funcdecl_entry_list = (struct ftdb_funcdecl_entry**)node->entry_list;
    PyObject* entry_list = PyList_New(0);
    for (unsigned long i=0; i<node->entry_count; ++i) {
        struct ftdb_funcdecl_entry* funcdecl_entry = (struct ftdb_funcdecl_entry*)(funcdecl_entry_list[i]);
        PyObject* args = PyTuple_New(2);
        PYTUPLE_SET_ULONG(args,0,(uintptr_t)self);
        PYTUPLE_SET_ULONG(args,1,funcdecl_entry->__index);
        PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFuncdeclsEntryType, args);
        Py_DecRef(args);
        PyList_Append(entry_list,entry);
        Py_DecRef(entry);
    }
    return entry_list;
}

static PyObject* libftdb_ftdb_funcdecls_contains_name_internal(libftdb_ftdb_funcdecls_object *self, const char *name) {

    struct stringRef_entryListMap_node* node = stringRef_entryListMap_search(&self->ftdb->fdnrefmap, name);
    if (node) {
        Py_RETURN_TRUE;
    }
    else {
        Py_RETURN_FALSE;
    }
}

PyObject* libftdb_ftdb_funcdecls_contains_name(libftdb_ftdb_funcdecls_object *self, PyObject *args) {

    const char* name;
    if(!PyArg_ParseTuple(args, "s", &name))
        return NULL;

    return libftdb_ftdb_funcdecls_contains_name_internal(self,name);
}

int libftdb_ftdb_funcdecls_sq_contains(PyObject* self, PyObject* key) {

    libftdb_ftdb_funcdecls_object* __self = (libftdb_ftdb_funcdecls_object*)self;

    if (PyUnicode_Check(key)) {
        /* Check hash */
        const char* hash;
        if(!PyArg_ParseTuple(key, "s", &hash))
            return -1;

        PyObject* v = libftdb_ftdb_funcdecls_contains_hash_internal(__self,hash);
        if (v) {
            return PyObject_IsTrue(v);
        }
    }
    else if (PyLong_Check(key)) {
        /* Check id */
        unsigned long id = PyLong_AsUnsignedLong(key);
        PyObject* v = libftdb_ftdb_funcdecls_contains_id_internal(__self,id);
        if (v) {
            return PyObject_IsTrue(v);
        }
    }

    PyErr_SetString(libftdb_ftdbError, "Invalid key type in contains check (not a str or integer)");
    return 0;
}

void libftdb_ftdb_funcdecl_entry_dealloc(libftdb_ftdb_funcdecl_entry_object* self) {

    Py_DecRef((PyObject*)self->funcdecls);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_funcdecl_entry_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    libftdb_ftdb_funcdecl_entry_object* self;

    self = (libftdb_ftdb_funcdecl_entry_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->funcdecls = (const libftdb_ftdb_funcdecls_object*)PyLong_AsLong(PyTuple_GetItem(args,0));
        Py_IncRef((PyObject*)self->funcdecls);
        unsigned long index = PyLong_AsLong(PyTuple_GetItem(args,1));
        if (index>=self->funcdecls->ftdb->funcdecls_count) {
            PyErr_SetString(libftdb_ftdbError, "funcdecl entry index out of bounds");
            return 0;
        }
        self->index = index;
        self->entry = &self->funcdecls->ftdb->funcdecls[self->index];
    }

    return (PyObject *)self;
}

PyObject* libftdb_ftdb_funcdecl_entry_repr(PyObject* self) {

    static char repr[1024];

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;
    int written = snprintf(repr,1024,"<ftdbFuncdeclEntry object at %lx : ",(uintptr_t)self);
    written+=snprintf(repr+written,1024-written,"id:%lu|name:%s>",__self->entry->id,__self->entry->name);

    return PyUnicode_FromString(repr);
}

PyObject* libftdb_ftdb_funcdecl_entry_json(libftdb_ftdb_funcdecl_entry_object *self, PyObject *args) {

    PyObject* json_entry = PyDict_New();

    FTDB_SET_ENTRY_STRING(json_entry,name,self->entry->name);
    FTDB_SET_ENTRY_STRING_OPTIONAL(json_entry,namespace,self->entry->__namespace);
    FTDB_SET_ENTRY_ULONG(json_entry,id,self->entry->id);
    FTDB_SET_ENTRY_ULONG(json_entry,fid,self->entry->fid);
    FTDB_SET_ENTRY_ULONG(json_entry,nargs,self->entry->nargs);
    FTDB_SET_ENTRY_BOOL(json_entry,variadic,self->entry->isvariadic);
    FTDB_SET_ENTRY_BOOL_OPTIONAL(json_entry,template,self->entry->istemplate);
    FTDB_SET_ENTRY_ENUM_TO_STRING(json_entry,linkage,self->entry->linkage,functionLinkage);
    FTDB_SET_ENTRY_BOOL_OPTIONAL(json_entry,member,self->entry->ismember);
    FTDB_SET_ENTRY_STRING_OPTIONAL(json_entry,class,self->entry->__class);
    FTDB_SET_ENTRY_ULONG_OPTIONAL(json_entry,classid,self->entry->classid);
    FTDB_SET_ENTRY_STRING_OPTIONAL(json_entry,template_parameters,self->entry->template_parameters);
    FTDB_SET_ENTRY_STRING(json_entry,decl,self->entry->decl);
    FTDB_SET_ENTRY_STRING(json_entry,signature,self->entry->signature);
    FTDB_SET_ENTRY_STRING(json_entry,declhash,self->entry->declhash);
    FTDB_SET_ENTRY_STRING(json_entry,location,self->entry->location);
    FTDB_SET_ENTRY_ULONG(json_entry,refcount,self->entry->refcount);
    FTDB_SET_ENTRY_ULONG_ARRAY(json_entry,types,self->entry->types);

    return json_entry;
}

PyObject* libftdb_ftdb_funcdecl_entry_has_namespace(libftdb_ftdb_funcdecl_entry_object *self, PyObject *args) {

    if (self->entry->__namespace) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_funcdecl_entry_has_class(libftdb_ftdb_funcdecl_entry_object *self, PyObject *args) {

    if ((self->entry->__class)||(self->entry->classid)) {
        if (!self->entry->__class) {
            PyErr_SetString(libftdb_ftdbError, "No 'class' field in function decl entry");
            return 0;
        }
        if (!self->entry->classid) {
            PyErr_SetString(libftdb_ftdbError, "No 'classid' field in function decl entry");
            return 0;
        }
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_funcdecl_entry_get_id(PyObject* self, void* closure) {

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;
    return PyLong_FromUnsignedLong(__self->entry->id);
}

PyObject* libftdb_ftdb_funcdecl_entry_get_name(PyObject* self, void* closure) {

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;
    return PyUnicode_FromString(__self->entry->name);
}

PyObject* libftdb_ftdb_funcdecl_entry_get_namespace(PyObject* self, void* closure) {

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;

    if (!__self->entry->__namespace) {
        PyErr_SetString(libftdb_ftdbError, "No 'namespace' field in function decl entry");
        return 0;
    }

    return PyUnicode_FromString(__self->entry->__namespace);
}

PyObject* libftdb_ftdb_funcdecl_entry_get_fid(PyObject* self, void* closure) {

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;
    return PyLong_FromUnsignedLong(__self->entry->fid);
}

PyObject* libftdb_ftdb_funcdecl_entry_get_nargs(PyObject* self, void* closure) {

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;
    return PyLong_FromUnsignedLong(__self->entry->nargs);
}

PyObject* libftdb_ftdb_funcdecl_entry_get_variadic(PyObject* self, void* closure) {

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;

    if (__self->entry->isvariadic) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_funcdecl_entry_get_template(PyObject* self, void* closure) {

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;

    if ((__self->entry->istemplate) && (*__self->entry->istemplate)) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_funcdecl_entry_get_linkage(PyObject* self, void* closure) {

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;
    return PyLong_FromLong((long)__self->entry->linkage);
}

PyObject* libftdb_ftdb_funcdecl_entry_get_linkage_string(PyObject* self, void* closure) {

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;
    return PyUnicode_FromString(set_functionLinkage(__self->entry->linkage));
}

PyObject* libftdb_ftdb_funcdecl_entry_get_member(PyObject* self, void* closure) {

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;

    if ((__self->entry->ismember) && (*__self->entry->ismember)) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_funcdecl_entry_get_class(PyObject* self, void* closure) {

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;

    if (!__self->entry->__class) {
        PyErr_SetString(libftdb_ftdbError, "No 'class' field in function decl entry");
        return 0;
    }

    return PyUnicode_FromString(__self->entry->__class);
}

PyObject* libftdb_ftdb_funcdecl_entry_get_classid(PyObject* self, void* closure) {

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;

    if (!__self->entry->classid) {
        PyErr_SetString(libftdb_ftdbError, "No 'classid' field in function decl entry");
        return 0;
    }

    return PyLong_FromUnsignedLong(*__self->entry->classid);
}

PyObject* libftdb_ftdb_funcdecl_entry_get_template_parameters(PyObject* self, void* closure) {

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;

    if (!__self->entry->template_parameters) {
        PyErr_SetString(libftdb_ftdbError, "No 'template_parameters' field in function decl entry");
        return 0;
    }

    return PyUnicode_FromString(__self->entry->template_parameters);
}

PyObject* libftdb_ftdb_funcdecl_entry_get_decl(PyObject* self, void* closure) {

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;
    return PyUnicode_FromString(__self->entry->decl);
}

PyObject* libftdb_ftdb_funcdecl_entry_get_signature(PyObject* self, void* closure) {

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;
    return PyUnicode_FromString(__self->entry->signature);
}

PyObject* libftdb_ftdb_funcdecl_entry_get_declhash(PyObject* self, void* closure) {

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;
    return PyUnicode_FromString(__self->entry->declhash);
}

PyObject* libftdb_ftdb_funcdecl_entry_get_location(PyObject* self, void* closure) {

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;
    return PyUnicode_FromString(__self->entry->location);
}

PyObject* libftdb_ftdb_funcdecl_entry_get_refcount(PyObject* self, void* closure) {

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;
    return PyLong_FromUnsignedLong(__self->entry->refcount);
}

PyObject* libftdb_ftdb_funcdecl_entry_get_types(PyObject* self, void* closure) {

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;

    PyObject* types = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->types_count; ++i) {
        PYLIST_ADD_ULONG(types,__self->entry->types[i]);
    }
    return types;
}

PyObject* libftdb_ftdb_funcdecl_entry_mp_subscript(PyObject* self, PyObject* slice) {

    static char errmsg[ERRMSG_BUFFER_SIZE];

    if (!PyUnicode_Check(slice)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in property mapping (not a str)");
        Py_RETURN_NONE;
    }

    const char* attr = PyString_get_c_str(slice);

    if (!strcmp(attr,"id")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_funcdecl_entry_get_id(self,0);
    }
    else if (!strcmp(attr,"name")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_funcdecl_entry_get_name(self,0);
    }
    else if (!strcmp(attr,"namespace")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_funcdecl_entry_get_namespace(self,0);
    }
    else if (!strcmp(attr,"fid")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_funcdecl_entry_get_fid(self,0);
    }
    else if (!strcmp(attr,"nargs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_funcdecl_entry_get_nargs(self,0);
    }
    else if (!strcmp(attr,"variadic")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_funcdecl_entry_get_variadic(self,0);
    }
    else if (!strcmp(attr,"template")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_funcdecl_entry_get_template(self,0);
    }
    else if (!strcmp(attr,"linkage")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_funcdecl_entry_get_linkage_string(self,0);
    }
    else if (!strcmp(attr,"member")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_funcdecl_entry_get_member(self,0);
    }
    else if (!strcmp(attr,"class")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_funcdecl_entry_get_class(self,0);
    }
    else if (!strcmp(attr,"classid")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_funcdecl_entry_get_classid(self,0);
    }
    else if (!strcmp(attr,"template_parameters")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_funcdecl_entry_get_template_parameters(self,0);
    }
    else if (!strcmp(attr,"decl")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_funcdecl_entry_get_decl(self,0);
    }
    else if (!strcmp(attr,"signature")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_funcdecl_entry_get_signature(self,0);
    }
    else if (!strcmp(attr,"declhash")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_funcdecl_entry_get_declhash(self,0);
    }
    else if (!strcmp(attr,"location")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_funcdecl_entry_get_location(self,0);
    }
    else if (!strcmp(attr,"refcount")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_funcdecl_entry_get_refcount(self,0);
    }
    else if (!strcmp(attr,"types")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_funcdecl_entry_get_types(self,0);
    }

    snprintf(errmsg,ERRMSG_BUFFER_SIZE,"Invalid attribute name: %s",attr);
    PyErr_SetString(libftdb_ftdbError, errmsg);
    PYASSTR_DECREF(attr);
    Py_RETURN_NONE;
}

int libftdb_ftdb_funcdecl_entry_sq_contains(PyObject* self, PyObject* key) {

    if (!PyUnicode_Check(key)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in contains check (not a str)");
        return 0;
    }

    libftdb_ftdb_funcdecl_entry_object* __self = (libftdb_ftdb_funcdecl_entry_object*)self;
    const char* attr = PyString_get_c_str(key);

    if (!strcmp(attr,"id")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"name")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"namespace")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->__namespace;
    }
    else if (!strcmp(attr,"fid")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"nargs")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"variadic")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"template")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->istemplate;
    }
    else if (!strcmp(attr,"linkage")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"member")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->ismember;
    }
    else if (!strcmp(attr,"class")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->__class;
    }
    else if (!strcmp(attr,"classid")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->classid;
    }
    else if (!strcmp(attr,"template_parameters")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->template_parameters;
    }
    else if (!strcmp(attr,"decl")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"signature")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"declhash")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"location")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"refcount")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"types")) {
        PYASSTR_DECREF(attr);
        return 1;
    }

    return 0;
}

PyObject* libftdb_ftdb_funcdecl_entry_deepcopy(PyObject* self, PyObject* memo) {

    Py_INCREF(self);
    return (PyObject *)self;
}

void libftdb_ftdb_unresolvedfuncs_dealloc(libftdb_ftdb_unresolvedfuncs_object* self) {

    Py_DecRef((PyObject*)self->py_ftdb);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_unresolvedfuncs_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

   libftdb_ftdb_unresolvedfuncs_object* self;

    self = (libftdb_ftdb_unresolvedfuncs_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->ftdb = (const struct ftdb*)PyLong_AsLong(PyTuple_GetItem(args,0));
        self->py_ftdb = (const libftdb_ftdb_object*)PyLong_AsLong(PyTuple_GetItem(args,1));
        Py_IncRef((PyObject*)self->py_ftdb);
    }

    return (PyObject *)self;
}

PyObject* libftdb_ftdb_unresolvedfuncs_repr(PyObject* self) {

    static char repr[1024];

    libftdb_ftdb_unresolvedfuncs_object* __self = (libftdb_ftdb_unresolvedfuncs_object*)self;
    int written = snprintf(repr,1024,"<ftdbUnresolvedfuncs object at %lx : ",(uintptr_t)self);
    written+=snprintf(repr+written,1024-written,"%ld unresolvedfuncs>",__self->ftdb->unresolvedfuncs_count);

    return PyUnicode_FromString(repr);
}

Py_ssize_t libftdb_ftdb_unresolvedfuncs_sq_length(PyObject* self) {

    libftdb_ftdb_unresolvedfuncs_object* __self = (libftdb_ftdb_unresolvedfuncs_object*)self;
    return __self->ftdb->unresolvedfuncs_count;
}

PyObject* libftdb_ftdb_unresolvedfuncs_getiter(PyObject* self) {

    libftdb_ftdb_unresolvedfuncs_object* __self = (libftdb_ftdb_unresolvedfuncs_object*)self;

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
    PYTUPLE_SET_ULONG(args,1,0);
    PyObject *iter = PyObject_CallObject((PyObject *) &libftdb_ftdbUnresolvedfuncsIterType, args);

    Py_DecRef(args);
    return iter;
}

PyObject* libftdb_ftdb_unresolvedfuncs_entry_deepcopy(PyObject* self, PyObject* memo) {

    Py_INCREF(self);
    return (PyObject *)self;
}

void libftdb_ftdb_unresolvedfuncs_iter_dealloc(libftdb_ftdb_unresolvedfuncs_iter_object* self) {

    Py_DecRef((PyObject*)self->unresolvedfuncs);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_unresolvedfuncs_iter_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

   libftdb_ftdb_unresolvedfuncs_iter_object* self;

    self = (libftdb_ftdb_unresolvedfuncs_iter_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->unresolvedfuncs = (libftdb_ftdb_unresolvedfuncs_object*)PyLong_AsLong(PyTuple_GetItem(args,0));
        Py_IncRef((PyObject*)self->unresolvedfuncs);
        self->index = PyLong_AsLong(PyTuple_GetItem(args,1));
    }

    return (PyObject *)self;
}

Py_ssize_t libftdb_ftdb_unresolvedfuncs_iter_sq_length(PyObject* self) {

    libftdb_ftdb_unresolvedfuncs_iter_object* __self = (libftdb_ftdb_unresolvedfuncs_iter_object*)self;
    return __self->unresolvedfuncs->ftdb->unresolvedfuncs_count;
}

PyObject* libftdb_ftdb_unresolvedfuncs_iter_next(PyObject *self) {

    libftdb_ftdb_unresolvedfuncs_iter_object* __self = (libftdb_ftdb_unresolvedfuncs_iter_object*)self;

    if (__self->index >= __self->unresolvedfuncs->ftdb->unresolvedfuncs_count) {
        /* Raising of standard StopIteration exception with empty value. */
        PyErr_SetNone(PyExc_StopIteration);
        return 0;
    }

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,__self->unresolvedfuncs->ftdb->unresolvedfuncs[__self->index].id);
    PYTUPLE_SET_STR(args,1,__self->unresolvedfuncs->ftdb->unresolvedfuncs[__self->index].name);
    __self->index++;
    return args;
}

void libftdb_ftdb_globals_dealloc(libftdb_ftdb_globals_object* self) {

    Py_DecRef((PyObject*)self->py_ftdb);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_globals_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

   libftdb_ftdb_globals_object* self;

    self = (libftdb_ftdb_globals_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->ftdb = (const struct ftdb*)PyLong_AsLong(PyTuple_GetItem(args,0));
        self->py_ftdb = (const libftdb_ftdb_object*)PyLong_AsLong(PyTuple_GetItem(args,1));
        Py_IncRef((PyObject*)self->py_ftdb);
    }

    return (PyObject *)self;
}

PyObject* libftdb_ftdb_globals_repr(PyObject* self) {

    static char repr[1024];

    libftdb_ftdb_globals_object* __self = (libftdb_ftdb_globals_object*)self;
    int written = snprintf(repr,1024,"<ftdbGlobals object at %lx : ",(uintptr_t)self);
    written+=snprintf(repr+written,1024-written,"%ld globals>",__self->ftdb->globals_count);

    return PyUnicode_FromString(repr);
}

Py_ssize_t libftdb_ftdb_globals_sq_length(PyObject* self) {

    libftdb_ftdb_globals_object* __self = (libftdb_ftdb_globals_object*)self;
    return __self->ftdb->globals_count;
}

PyObject* libftdb_ftdb_globals_getiter(PyObject* self) {

    libftdb_ftdb_globals_object* __self = (libftdb_ftdb_globals_object*)self;

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
    PYTUPLE_SET_ULONG(args,1,0);
    PyObject *iter = PyObject_CallObject((PyObject *) &libftdb_ftdbGlobalsIterType, args);

    Py_DecRef(args);
    return iter;
}

PyObject* libftdb_ftdb_globals_mp_subscript(PyObject* self, PyObject* slice) {

    static char errmsg[ERRMSG_BUFFER_SIZE];
    libftdb_ftdb_globals_object* __self = (libftdb_ftdb_globals_object*)self;

    if (PyLong_Check(slice)) {
        unsigned long id = PyLong_AsUnsignedLong(slice);
        struct ulong_entryMap_node* node = ulong_entryMap_search(&__self->ftdb->grefmap, id);
        if (!node) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"invalid global id not present in the array: %lu\n",id);
            PyErr_SetString(libftdb_ftdbError, errmsg);
            return 0;
        }
        struct ftdb_global_entry* global_entry = (struct ftdb_global_entry*)node->entry;
        PyObject* args = PyTuple_New(2);
        PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
        PYTUPLE_SET_ULONG(args,1,global_entry->__index);
        PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbGlobalEntryType, args);
        Py_DecRef(args);
        return entry;
    }
    else if (PyUnicode_Check(slice)) {
        const char* hash = PyString_get_c_str(slice);
        struct stringRef_entryMap_node* node = stringRef_entryMap_search(&__self->ftdb->ghrefmap, hash);
        if (!node) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"invalid global hash not present in the array: %s\n",hash);
            PYASSTR_DECREF(hash);
            PyErr_SetString(libftdb_ftdbError, errmsg);
            return 0;
        }
        PYASSTR_DECREF(hash);
        struct ftdb_global_entry* global_entry = (struct ftdb_global_entry*)node->entry;
        PyObject* args = PyTuple_New(2);
        PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
        PYTUPLE_SET_ULONG(args,1,global_entry->__index);
        PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbGlobalEntryType, args);
        Py_DecRef(args);
        return entry;
    }
    else {
        PyErr_SetString(libftdb_ftdbError, "Invalid subscript argument");
        return 0;
    }
}

PyObject* libftdb_ftdb_globals_entry_by_id(libftdb_ftdb_globals_object *self, PyObject *args) {

    unsigned long id;
    if(!PyArg_ParseTuple(args, "k", &id))
        return NULL;

    static char errmsg[ERRMSG_BUFFER_SIZE];

    struct ulong_entryMap_node* node = ulong_entryMap_search(&self->ftdb->grefmap, id);
    if (!node) {
        snprintf(errmsg,ERRMSG_BUFFER_SIZE,"invalid global id not present in the array: %lu\n",id);
        PyErr_SetString(libftdb_ftdbError, errmsg);
        return 0;
    }
    struct ftdb_global_entry* global_entry = (struct ftdb_global_entry*)node->entry;
    PyObject* _args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(_args,0,(uintptr_t)self);
    PYTUPLE_SET_ULONG(_args,1,global_entry->__index);
    PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbGlobalEntryType, _args);
    Py_DecRef(_args);
    return entry;
}

static PyObject* libftdb_ftdb_globals_contains_id_internal(libftdb_ftdb_globals_object *self, unsigned long id) {

    struct ulong_entryMap_node* node = ulong_entryMap_search(&self->ftdb->grefmap, id);
    if (node) {
        Py_RETURN_TRUE;
    }
    else {
        Py_RETURN_FALSE;
    }

}

PyObject* libftdb_ftdb_globals_contains_id(libftdb_ftdb_globals_object *self, PyObject *args) {

    unsigned long id;
    if(!PyArg_ParseTuple(args, "k", &id))
        return NULL;
    return libftdb_ftdb_globals_contains_id_internal(self,id);
}

PyObject* libftdb_ftdb_globals_entry_by_hash(libftdb_ftdb_globals_object *self, PyObject *args) {

    const char* hash;
    if(!PyArg_ParseTuple(args, "s", &hash))
        return NULL;

    static char errmsg[ERRMSG_BUFFER_SIZE];
    struct stringRef_entryMap_node* node = stringRef_entryMap_search(&self->ftdb->ghrefmap, hash);
    if (!node) {
        snprintf(errmsg,ERRMSG_BUFFER_SIZE,"invalid global hash not present in the array: %s\n",hash);
        PyErr_SetString(libftdb_ftdbError, errmsg);
        return 0;
    }
    struct ftdb_global_entry* global_entry = (struct ftdb_global_entry*)node->entry;
    PyObject* _args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(_args,0,(uintptr_t)self);
    PYTUPLE_SET_ULONG(_args,1,global_entry->__index);
    PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbGlobalEntryType, _args);
    Py_DecRef(_args);
    return entry;
}

static PyObject* libftdb_ftdb_globals_contains_hash_internal(libftdb_ftdb_globals_object *self, const char *hash) {

    struct stringRef_entryMap_node* node = stringRef_entryMap_search(&self->ftdb->ghrefmap, hash);
    if (node) {
        Py_RETURN_TRUE;
    }
    else {
        Py_RETURN_FALSE;
    }
}

PyObject* libftdb_ftdb_globals_contains_hash(libftdb_ftdb_globals_object *self, PyObject *args) {

    const char* hash;
    if(!PyArg_ParseTuple(args, "s", &hash))
        return NULL;
    return libftdb_ftdb_globals_contains_hash_internal(self,hash);
}

PyObject* libftdb_ftdb_globals_entry_by_name(libftdb_ftdb_globals_object *self, PyObject *args) {

    const char* name;
    if(!PyArg_ParseTuple(args, "s", &name))
        return NULL;

    static char errmsg[ERRMSG_BUFFER_SIZE];

    struct stringRef_entryListMap_node* node = stringRef_entryListMap_search(&self->ftdb->gnrefmap, name);
    if (!node) {
        snprintf(errmsg,ERRMSG_BUFFER_SIZE,"invalid global name not present in the array: %s\n",name);
        PyErr_SetString(libftdb_ftdbError, errmsg);
        return 0;
    }
    struct ftdb_global_entry** func_entry_list = (struct ftdb_global_entry**)node->entry_list;
    PyObject* entry_list = PyList_New(0);
    for (unsigned long i=0; i<node->entry_count; ++i) {
        struct ftdb_global_entry* global_entry = (struct ftdb_global_entry*)(func_entry_list[i]);
        PyObject* args = PyTuple_New(2);
        PYTUPLE_SET_ULONG(args,0,(uintptr_t)self);
        PYTUPLE_SET_ULONG(args,1,global_entry->__index);
        PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbGlobalEntryType, args);
        Py_DecRef(args);
        PyList_Append(entry_list,entry);
    }
    return entry_list;
}

static PyObject* libftdb_ftdb_globals_contains_name_internal(libftdb_ftdb_globals_object *self, const char *name) {

    struct stringRef_entryListMap_node* node = stringRef_entryListMap_search(&self->ftdb->gnrefmap, name);
    if (node) {
        Py_RETURN_TRUE;
    }
    else {
        Py_RETURN_FALSE;
    }
}

PyObject* libftdb_ftdb_globals_contains_name(libftdb_ftdb_globals_object *self, PyObject *args) {

    const char* name;
    if(!PyArg_ParseTuple(args, "s", &name))
        return NULL;
    
    return libftdb_ftdb_globals_contains_name_internal(self,name);

}

int libftdb_ftdb_globals_sq_contains(PyObject* self, PyObject* key) {

    libftdb_ftdb_globals_object* __self = (libftdb_ftdb_globals_object*)self;

    if (PyUnicode_Check(key)) {
        /* Check name */
        const char* name;
        if(!PyArg_Parse(key, "s", &name))
            return -1;

        PyObject* v = libftdb_ftdb_globals_contains_name_internal(__self,name);
        if (v) {
            return PyObject_IsTrue(v);
        }
    }
    else if (PyLong_Check(key)) {
        /* Check id */
        unsigned long id = PyLong_AsUnsignedLong(key);
        PyObject* v = libftdb_ftdb_globals_contains_id_internal(__self,id);
        if (v) {
            return PyObject_IsTrue(v);
        }
    }
    else if (PyTuple_Check(key)) {
        /* Check hash */
        const char* hash;
        if(!PyArg_ParseTuple(key, "s", &hash))
            return -1;

        PyObject* v = libftdb_ftdb_globals_contains_hash_internal(__self,hash);
        if (v) {
            return PyObject_IsTrue(v);
        }
    }

    PyErr_SetString(libftdb_ftdbError, "Invalid key type in contains check (not a str, tuple or integer)");
    return 0;
}

PyObject* libftdb_ftdb_globals_entry_deepcopy(PyObject* self, PyObject* memo) {

    Py_INCREF(self);
    return (PyObject *)self;
}

void libftdb_ftdb_globals_iter_dealloc(libftdb_ftdb_globals_iter_object* self) {

    Py_DecRef((PyObject*)self->globals);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_globals_iter_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    libftdb_ftdb_globals_iter_object* self;

    self = (libftdb_ftdb_globals_iter_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->globals = (libftdb_ftdb_globals_object*)PyLong_AsLong(PyTuple_GetItem(args,0));
        Py_IncRef((PyObject*)self->globals);
        self->index = PyLong_AsLong(PyTuple_GetItem(args,1));
    }

    return (PyObject *)self;
}

Py_ssize_t libftdb_ftdb_globals_iter_sq_length(PyObject* self) {

    libftdb_ftdb_globals_iter_object* __self = (libftdb_ftdb_globals_iter_object*)self;
    return __self->globals->ftdb->globals_count;
}

PyObject* libftdb_ftdb_globals_iter_next(PyObject *self) {

    libftdb_ftdb_globals_iter_object* __self = (libftdb_ftdb_globals_iter_object*)self;

    if (__self->index >= __self->globals->ftdb->globals_count) {
        /* Raising of standard StopIteration exception with empty value. */
        PyErr_SetNone(PyExc_StopIteration);
        return 0;
    }

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self->globals);
    PYTUPLE_SET_ULONG(args,1,__self->index);
    PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbGlobalEntryType, args);
    Py_DecRef(args);
    __self->index++;
    return entry;
}

void libftdb_ftdb_global_entry_dealloc(libftdb_ftdb_global_entry_object* self) {

    Py_DecRef((PyObject*)self->globals);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_global_entry_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

   libftdb_ftdb_global_entry_object* self;

    self = (libftdb_ftdb_global_entry_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->globals = (const libftdb_ftdb_globals_object*)PyLong_AsLong(PyTuple_GetItem(args,0));
        Py_IncRef((PyObject*)self->globals);
        unsigned long index = PyLong_AsLong(PyTuple_GetItem(args,1));
        if (index>=self->globals->ftdb->globals_count) {
            PyErr_SetString(libftdb_ftdbError, "global entry index out of bounds");
            return 0;
        }
        self->index = index;
        self->entry = &self->globals->ftdb->globals[self->index];
    }

    return (PyObject *)self;
}

PyObject* libftdb_ftdb_global_entry_repr(PyObject* self) {

    static char repr[1024];

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;
    int written = snprintf(repr,1024,"<ftdbGlobalEntry object at %lx : ",(uintptr_t)self);
    written+=snprintf(repr+written,1024-written,"id:%lu|name:%s>",__self->entry->id,__self->entry->name);

    return PyUnicode_FromString(repr);
}

PyObject* libftdb_ftdb_global_entry_has_init(libftdb_ftdb_global_entry_object *self, PyObject *args) {

    if (self->entry->hasinit) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_global_entry_get_name(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;
    return PyUnicode_FromString(__self->entry->name);
}

PyObject* libftdb_ftdb_global_entry_get_hash(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;
    return PyUnicode_FromString(__self->entry->hash);
}

PyObject* libftdb_ftdb_global_entry_get_id(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;
    return PyLong_FromUnsignedLong(__self->entry->id);
}

PyObject* libftdb_ftdb_global_entry_get_fid(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;
    return PyLong_FromUnsignedLong(__self->entry->fid);
}

PyObject* libftdb_ftdb_global_entry_get_def(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;
    return PyUnicode_FromString(__self->entry->def);
}

PyObject* libftdb_ftdb_global_entry_get_type(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;
    return PyLong_FromUnsignedLong(__self->entry->type);
}

PyObject* libftdb_ftdb_global_entry_get_linkage(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;
    return PyLong_FromLong((long)__self->entry->linkage);
}

PyObject* libftdb_ftdb_global_entry_get_linkage_string(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;
    return PyUnicode_FromString(set_functionLinkage(__self->entry->linkage));
}

PyObject* libftdb_ftdb_global_entry_get_location(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;
    return PyUnicode_FromString(__self->entry->location);
}

PyObject* libftdb_ftdb_global_entry_get_deftype(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;
    return PyLong_FromLong((long)__self->entry->deftype);
}

PyObject* libftdb_ftdb_global_entry_get_init(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;
    return PyUnicode_FromString(__self->entry->init);
}

PyObject* libftdb_ftdb_global_entry_get_globalrefs(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;

    PyObject* globalrefs = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->globalrefs_count; ++i) {
        PYLIST_ADD_ULONG(globalrefs,__self->entry->globalrefs[i]);
    }
    return globalrefs;
}

PyObject* libftdb_ftdb_global_entry_get_refs(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;

    PyObject* refs = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->refs_count; ++i) {
        PYLIST_ADD_ULONG(refs,__self->entry->refs[i]);
    }
    return refs;
}

PyObject* libftdb_ftdb_global_entry_get_funrefs(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;

    PyObject* funrefs = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->funrefs_count; ++i) {
        PYLIST_ADD_ULONG(funrefs,__self->entry->funrefs[i]);
    }
    return funrefs;
}

PyObject* libftdb_ftdb_global_entry_get_decls(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;

    PyObject* decls = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->decls_count; ++i) {
        PYLIST_ADD_ULONG(decls,__self->entry->decls[i]);
    }
    return decls;
}

PyObject* libftdb_ftdb_global_entry_get_mids(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;

    if (!__self->entry->mids) {
        Py_RETURN_NONE;
    }

    PyObject* mids = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->mids_count; ++i) {
        PYLIST_ADD_ULONG(mids,__self->entry->mids[i]);
    }
    return mids;
}

PyObject* libftdb_ftdb_global_entry_get_literals(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;

    PyObject* literals = PyDict_New();
    FTDB_SET_ENTRY_INT64_ARRAY(literals,integer,__self->entry->integer_literals);
    FTDB_SET_ENTRY_UINT_ARRAY(literals,character,__self->entry->character_literals);
    FTDB_SET_ENTRY_FLOAT_ARRAY(literals,floating,__self->entry->floating_literals);
    FTDB_SET_ENTRY_STRING_ARRAY(literals,string,__self->entry->string_literals);

    return literals;
}

PyObject* libftdb_ftdb_global_entry_get_hasinit(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;
    return PyLong_FromLong(__self->entry->hasinit);
}

PyObject* libftdb_ftdb_global_entry_get_integer_literals(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;

    PyObject* integer_literals = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->integer_literals_count; ++i) {
        PYLIST_ADD_LONG(integer_literals,__self->entry->integer_literals[i]);
    }
    return integer_literals;
}

PyObject* libftdb_ftdb_global_entry_get_character_literals(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;

    PyObject* character_literals = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->character_literals_count; ++i) {
        PYLIST_ADD_LONG(character_literals,__self->entry->character_literals[i]);
    }
    return character_literals;
}

PyObject* libftdb_ftdb_global_entry_get_floating_literals(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;

    PyObject* floating_literals = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->floating_literals_count; ++i) {
        PYLIST_ADD_FLOAT(floating_literals,__self->entry->floating_literals[i]);
    }
    return floating_literals;
}

PyObject* libftdb_ftdb_global_entry_get_string_literals(PyObject* self, void* closure) {

    libftdb_ftdb_global_entry_object* __self = (libftdb_ftdb_global_entry_object*)self;

    PyObject* string_literals = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->string_literals_count; ++i) {
        PYLIST_ADD_STRING(string_literals,__self->entry->string_literals[i]);
    }
    return string_literals;
}

PyObject* libftdb_ftdb_global_entry_mp_subscript(PyObject* self, PyObject* slice) {

    static char errmsg[ERRMSG_BUFFER_SIZE];

    if (!PyUnicode_Check(slice)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in property mapping (not a str)");
        Py_RETURN_NONE;
    }

    const char* attr = PyString_get_c_str(slice);

    if (!strcmp(attr,"name")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_global_entry_get_name(self,0);
    }
    else if (!strcmp(attr,"hash")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_global_entry_get_hash(self,0);
    }
    else if (!strcmp(attr,"id")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_global_entry_get_id(self,0);
    }
    else if (!strcmp(attr,"fid")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_global_entry_get_fid(self,0);
    }
    else if (!strcmp(attr,"def")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_global_entry_get_def(self,0);
    }
    else if (!strcmp(attr,"type")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_global_entry_get_type(self,0);
    }
    else if (!strcmp(attr,"linkage")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_global_entry_get_linkage_string(self,0);
    }
    else if (!strcmp(attr,"location")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_global_entry_get_location(self,0);
    }
    else if (!strcmp(attr,"deftype")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_global_entry_get_deftype(self,0);
    }
    else if (!strcmp(attr,"init")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_global_entry_get_init(self,0);
    }
    else if (!strcmp(attr,"globalrefs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_global_entry_get_globalrefs(self,0);
    }
    else if (!strcmp(attr,"refs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_global_entry_get_refs(self,0);
    }
    else if (!strcmp(attr,"funrefs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_global_entry_get_funrefs(self,0);
    }
    else if (!strcmp(attr,"decls")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_global_entry_get_decls(self,0);
    }
    else if (!strcmp(attr,"mids")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_global_entry_get_mids(self,0);
    }
    else if (!strcmp(attr,"literals")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_global_entry_get_literals(self,0);
    }
    else if (!strcmp(attr,"hasinit")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_global_entry_get_hasinit(self,0);
    }

    snprintf(errmsg,ERRMSG_BUFFER_SIZE,"Invalid attribute name: %s",attr);
    PyErr_SetString(libftdb_ftdbError, errmsg);
    PYASSTR_DECREF(attr);
    Py_RETURN_NONE;
}

int libftdb_ftdb_global_entry_sq_contains(PyObject* self, PyObject* key) {

    if (!PyUnicode_Check(key)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in contains check (not a str)");
        return 0;
    }

    const char* attr = PyString_get_c_str(key);

    if (!strcmp(attr,"name")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"hash")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"id")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"fid")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"def")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"file")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"type")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"linkage")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"location")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"deftype")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"init")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"globalrefs")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"refs")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"funrefs")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"decls")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"mids")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"literals")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"hasinit")) {
        PYASSTR_DECREF(attr);
        return 1;
    }

    return 0;
}

PyObject* libftdb_ftdb_global_entry_deepcopy(PyObject* self, PyObject* memo) {

    Py_INCREF(self);
    return (PyObject *)self;
}

PyObject* libftdb_ftdb_global_entry_json(libftdb_ftdb_global_entry_object *self, PyObject *args) {

    PyObject* json_entry = PyDict_New();

    FTDB_SET_ENTRY_STRING(json_entry,name,self->entry->name);
    FTDB_SET_ENTRY_STRING(json_entry,hash,self->entry->hash);
    FTDB_SET_ENTRY_ULONG(json_entry,id,self->entry->id);
    FTDB_SET_ENTRY_STRING(json_entry,def,self->entry->def);
    FTDB_SET_ENTRY_ULONG_ARRAY(json_entry,globalrefs,self->entry->globalrefs);
    FTDB_SET_ENTRY_ULONG_ARRAY(json_entry,refs,self->entry->refs);
    FTDB_SET_ENTRY_ULONG_ARRAY(json_entry,funrefs,self->entry->funrefs);
    FTDB_SET_ENTRY_ULONG_ARRAY(json_entry,decls,self->entry->decls);
    FTDB_SET_ENTRY_ULONG_ARRAY_OPTIONAL(json_entry,mids,self->entry->mids);
    FTDB_SET_ENTRY_ULONG(json_entry,fid,self->entry->fid);
    FTDB_SET_ENTRY_ULONG(json_entry,type,self->entry->type);
    FTDB_SET_ENTRY_ENUM_TO_STRING(json_entry,linkage,self->entry->linkage,functionLinkage);
    FTDB_SET_ENTRY_STRING(json_entry,location,self->entry->location);
    FTDB_SET_ENTRY_ULONG(json_entry,deftype,(unsigned long)self->entry->deftype);
    FTDB_SET_ENTRY_INT(json_entry,hasinit,self->entry->hasinit);
    FTDB_SET_ENTRY_STRING(json_entry,init,self->entry->init);

    PyObject* literals = PyDict_New();
    FTDB_SET_ENTRY_INT64_ARRAY(literals,integer,self->entry->integer_literals);
    FTDB_SET_ENTRY_INT_ARRAY(literals,character,self->entry->character_literals);
    FTDB_SET_ENTRY_FLOAT_ARRAY(literals,floating,self->entry->floating_literals);
    FTDB_SET_ENTRY_STRING_ARRAY(literals,string,self->entry->string_literals);
    FTDB_SET_ENTRY_PYOBJECT(json_entry,literals,literals);

    return json_entry;
}

void libftdb_ftdb_types_dealloc(libftdb_ftdb_types_object* self) {

    Py_DecRef((PyObject*)self->py_ftdb);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}
PyObject* libftdb_ftdb_types_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

   libftdb_ftdb_types_object* self;

    self = (libftdb_ftdb_types_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->ftdb = (const struct ftdb*)PyLong_AsLong(PyTuple_GetItem(args,0));
        self->py_ftdb = (const libftdb_ftdb_object*)PyLong_AsLong(PyTuple_GetItem(args,1));
        Py_IncRef((PyObject*)self->py_ftdb);
    }

    return (PyObject *)self;
}

PyObject* libftdb_ftdb_types_repr(PyObject* self) {

    static char repr[1024];

    libftdb_ftdb_types_object* __self = (libftdb_ftdb_types_object*)self;
    int written = snprintf(repr,1024,"<ftdbTypes object at %lx : ",(uintptr_t)self);
    written+=snprintf(repr+written,1024-written,"%ld types>",__self->ftdb->types_count);

    return PyUnicode_FromString(repr);
}

Py_ssize_t libftdb_ftdb_types_sq_length(PyObject* self) {

    libftdb_ftdb_types_object* __self = (libftdb_ftdb_types_object*)self;
    return __self->ftdb->types_count;
}

PyObject* libftdb_ftdb_types_getiter(PyObject* self) {

    libftdb_ftdb_types_object* __self = (libftdb_ftdb_types_object*)self;

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
    PYTUPLE_SET_ULONG(args,1,0);
    PyObject *iter = PyObject_CallObject((PyObject *) &libftdb_ftdbTypesIterType, args);

    Py_DecRef(args);
    return iter;
}

PyObject* libftdb_ftdb_types_mp_subscript(PyObject* self, PyObject* slice) {

    static char errmsg[ERRMSG_BUFFER_SIZE];
    libftdb_ftdb_types_object* __self = (libftdb_ftdb_types_object*)self;

    if (PyLong_Check(slice)) {
        unsigned long id = PyLong_AsUnsignedLong(slice);
        struct ulong_entryMap_node* node = ulong_entryMap_search(&__self->ftdb->refmap, id);
        if (!node) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"invalid type id not present in the array: %lu\n",id);
            PyErr_SetString(libftdb_ftdbError, errmsg);
            return 0;
        }
        struct ftdb_type_entry* type_entry = (struct ftdb_type_entry*)node->entry;
        PyObject* args = PyTuple_New(2);
        PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
        PYTUPLE_SET_ULONG(args,1,type_entry->__index);
        PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbTypeEntryType, args);
        Py_DecRef(args);
        return entry;
    }
    else if (PyUnicode_Check(slice)) {
        const char* hash = PyString_get_c_str(slice);
        struct stringRef_entryMap_node* node = stringRef_entryMap_search(&__self->ftdb->hrefmap, hash);
        if (!node) {
            snprintf(errmsg,ERRMSG_BUFFER_SIZE,"invalid type hash not present in the array: %s\n",hash);
            PYASSTR_DECREF(hash);
            PyErr_SetString(libftdb_ftdbError, errmsg);
            return 0;
        }
        PYASSTR_DECREF(hash);
        struct ftdb_type_entry* type_entry = (struct ftdb_type_entry*)node->entry;
        PyObject* args = PyTuple_New(2);
        PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
        PYTUPLE_SET_ULONG(args,1,type_entry->__index);
        PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbTypeEntryType, args);
        Py_DecRef(args);
        return entry;
    }
    else {
        PyErr_SetString(libftdb_ftdbError, "Invalid subscript argument");
        return 0;
    }

}

static PyObject* libftdb_ftdb_types_contains_hash_internal(libftdb_ftdb_types_object *self, const char *hash) {

    struct stringRef_entryMap_node* node = stringRef_entryMap_search(&self->ftdb->hrefmap, hash);
    if (node) {
        Py_RETURN_TRUE;
    }
    else {
        Py_RETURN_FALSE;
    }
}

PyObject* libftdb_ftdb_types_contains_hash(libftdb_ftdb_types_object *self, PyObject *args) {

    const char* hash;
    if(!PyArg_ParseTuple(args, "s", &hash))
        return NULL;
    return libftdb_ftdb_types_contains_hash_internal(self,hash);
}

static PyObject* libftdb_ftdb_types_contains_id_internal(libftdb_ftdb_types_object *self, unsigned long id) {

    struct ulong_entryMap_node* node = ulong_entryMap_search(&self->ftdb->refmap, id);
    if (node) {
        Py_RETURN_TRUE;
    }
    else {
        Py_RETURN_FALSE;
    }
}

PyObject* libftdb_ftdb_types_contains_id(libftdb_ftdb_types_object *self, PyObject *args) {

    unsigned long id;
    if(!PyArg_ParseTuple(args, "k", &id))
        return NULL;
    return libftdb_ftdb_types_contains_id_internal(self,id);
}

PyObject* libftdb_ftdb_types_entry_by_hash(libftdb_ftdb_types_object *self, PyObject *args) {

    const char* hash;
    if(!PyArg_ParseTuple(args, "s", &hash))
        return NULL;

    static char errmsg[ERRMSG_BUFFER_SIZE];
    struct stringRef_entryMap_node* node = stringRef_entryMap_search(&self->ftdb->hrefmap, hash);
    if (!node) {
        snprintf(errmsg,ERRMSG_BUFFER_SIZE,"invalid function hash not present in the array: %s\n",hash);
        PyErr_SetString(libftdb_ftdbError, errmsg);
        return 0;
    }
    struct ftdb_type_entry* types_entry = (struct ftdb_type_entry*)node->entry;
    PyObject* _args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(_args,0,(uintptr_t)self);
    PYTUPLE_SET_ULONG(_args,1,types_entry->__index);
    PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbTypeEntryType, _args);
    Py_DecRef(_args);
    return entry;
}

PyObject* libftdb_ftdb_types_entry_by_id(libftdb_ftdb_types_object *self, PyObject *args) {

    unsigned long id;
    if(!PyArg_ParseTuple(args, "k", &id))
        return NULL;

    static char errmsg[ERRMSG_BUFFER_SIZE];

    struct ulong_entryMap_node* node = ulong_entryMap_search(&self->ftdb->refmap, id);
    if (!node) {
        snprintf(errmsg,ERRMSG_BUFFER_SIZE,"invalid function id not present in the array: %lu\n",id);
        PyErr_SetString(libftdb_ftdbError, errmsg);
        return 0;
    }
    struct ftdb_type_entry* types_entry = (struct ftdb_type_entry*)node->entry;
    PyObject* _args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(_args,0,(uintptr_t)self);
    PYTUPLE_SET_ULONG(_args,1,types_entry->__index);
    PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbTypeEntryType, _args);
    Py_DecRef(_args);
    return entry;
}

int libftdb_ftdb_types_sq_contains(PyObject* self, PyObject* key) {

    libftdb_ftdb_types_object* __self = (libftdb_ftdb_types_object*)self;

    if (PyUnicode_Check(key)) {
        /* Check hash */
        const char* hash;
        if(!PyArg_Parse(key, "s", &hash))
            return -1;
        PyObject* v = libftdb_ftdb_types_contains_hash_internal(__self,hash);
        if (v) {
            return PyObject_IsTrue(v);
        }
    }
    else if (PyLong_Check(key)) {
        /* Check id */
        unsigned long id = PyLong_AsUnsignedLong(key);
        PyObject* v = libftdb_ftdb_types_contains_id_internal(__self,id);
        if (v) {
            return PyObject_IsTrue(v);
        }
    }

    PyErr_SetString(libftdb_ftdbError, "Invalid key type in contains check (not a str or integer)");
    return 0;


}

void libftdb_ftdb_types_iter_dealloc(libftdb_ftdb_types_iter_object* self) {

    Py_DecRef((PyObject*)self->types);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_types_iter_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    libftdb_ftdb_types_iter_object* self;

    self = (libftdb_ftdb_types_iter_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->types = (libftdb_ftdb_types_object*)PyLong_AsLong(PyTuple_GetItem(args,0));
        Py_IncRef((PyObject*)self->types);
        self->index = PyLong_AsLong(PyTuple_GetItem(args,1));
    }

    return (PyObject *)self;
}

Py_ssize_t libftdb_ftdb_types_iter_sq_length(PyObject* self) {

    libftdb_ftdb_types_iter_object* __self = (libftdb_ftdb_types_iter_object*)self;
    return __self->types->ftdb->types_count;
}

PyObject* libftdb_ftdb_types_iter_next(PyObject *self) {

    libftdb_ftdb_types_iter_object* __self = (libftdb_ftdb_types_iter_object*)self;

    if (__self->index >= __self->types->ftdb->types_count) {
        /* Raising of standard StopIteration exception with empty value. */
        PyErr_SetNone(PyExc_StopIteration);
        return 0;
    }

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self->types);
    PYTUPLE_SET_ULONG(args,1,__self->index);
    PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbTypeEntryType, args);
    Py_DecRef(args);
    __self->index++;
    return entry;
}

void libftdb_ftdb_type_entry_dealloc(libftdb_ftdb_type_entry_object* self) {

    Py_DecRef((PyObject*)self->types);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_type_entry_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    libftdb_ftdb_type_entry_object* self;

    self = (libftdb_ftdb_type_entry_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->types = (const libftdb_ftdb_types_object*)PyLong_AsLong(PyTuple_GetItem(args,0));
        Py_IncRef((PyObject*)self->types);
        unsigned long index = PyLong_AsLong(PyTuple_GetItem(args,1));
        if (index>=self->types->ftdb->types_count) {
            PyErr_SetString(libftdb_ftdbError, "type entry index out of bounds");
            return 0;
        }
        self->index = index;
        self->entry = &self->types->ftdb->types[self->index];
    }

    return (PyObject *)self;
}

PyObject* libftdb_ftdb_type_entry_repr(PyObject* self) {

    static char repr[1024];

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;
    int written = snprintf(repr,1024,"<ftdbTypeEntry object at %lx : ",(uintptr_t)self);
    written+=snprintf(repr+written,1024-written,"id:%lu|class:%s,str:%s>",__self->entry->id,__self->entry->class_name,__self->entry->str);

    return PyUnicode_FromString(repr);
}

PyObject* libftdb_ftdb_type_entry_get_id(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;
    return PyLong_FromUnsignedLong(__self->entry->id);
}

PyObject* libftdb_ftdb_type_entry_get_fid(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;
    return PyLong_FromUnsignedLong(__self->entry->fid);
}

PyObject* libftdb_ftdb_type_entry_get_hash(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;
    return PyUnicode_FromString(__self->entry->hash);
}

PyObject* libftdb_ftdb_type_entry_get_classname(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;
    return PyUnicode_FromString(__self->entry->class_name);
}

PyObject* libftdb_ftdb_type_entry_get_classid(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;
    return PyLong_FromLong((long)__self->entry->__class);
}

PyObject* libftdb_ftdb_type_entry_get_qualifiers(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;
    return PyUnicode_FromString(__self->entry->qualifiers);
}

PyObject* libftdb_ftdb_type_entry_get_size(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;
    return PyLong_FromUnsignedLong(__self->entry->size);
}

PyObject* libftdb_ftdb_type_entry_get_str(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;
    return PyUnicode_FromString(__self->entry->str);
}

PyObject* libftdb_ftdb_type_entry_get_refcount(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;
    return PyLong_FromUnsignedLong(__self->entry->refcount);
}

PyObject* libftdb_ftdb_type_entry_get_refs(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    PyObject* refs = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->refs_count; ++i) {
        PYLIST_ADD_ULONG(refs,__self->entry->refs[i]);
    }
    return refs;
}

PyObject* libftdb_ftdb_type_entry_get_usedrefs(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if (!__self->entry->usedrefs) {
        PyErr_SetString(libftdb_ftdbError, "No 'usedrefs' field in type entry");
        return 0;
    }

    PyObject* usedrefs = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->usedrefs_count; ++i) {
        PYLIST_ADD_LONG(usedrefs,__self->entry->usedrefs[i]);
    }
    return usedrefs;
}

PyObject* libftdb_ftdb_type_entry_get_decls(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if (!__self->entry->decls) {
        PyErr_SetString(libftdb_ftdbError, "No 'decls' field in type entry");
        return 0;
    }

    PyObject* decls = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->decls_count; ++i) {
        PYLIST_ADD_ULONG(decls,__self->entry->decls[i]);
    }
    return decls;
}

PyObject* libftdb_ftdb_type_entry_get_def(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if (!__self->entry->def) {
        PyErr_SetString(libftdb_ftdbError, "No 'def' field in type entry");
        return 0;
    }

    return PyUnicode_FromString(__self->entry->def);
}

PyObject* libftdb_ftdb_type_entry_get_memberoffsets(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if (!__self->entry->memberoffsets) {
        PyErr_SetString(libftdb_ftdbError, "No 'memberoffsets' field in type entry");
        return 0;
    }

    PyObject* memberoffsets = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->memberoffsets_count; ++i) {
        PYLIST_ADD_ULONG(memberoffsets,__self->entry->memberoffsets[i]);
    }
    return memberoffsets;
}

PyObject* libftdb_ftdb_type_entry_get_attrrefs(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if (!__self->entry->attrrefs) {
        PyErr_SetString(libftdb_ftdbError, "No 'attrrefs' field in type entry");
        return 0;
    }

    PyObject* attrrefs = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->attrrefs_count; ++i) {
        PYLIST_ADD_ULONG(attrrefs,__self->entry->attrrefs[i]);
    }
    return attrrefs;
}

PyObject* libftdb_ftdb_type_entry_get_attrnum(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if (!__self->entry->attrnum) {
        return PyLong_FromUnsignedLong(0);
    }

    return PyLong_FromUnsignedLong(*__self->entry->attrnum);
}

PyObject* libftdb_ftdb_type_entry_get_name(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if (!__self->entry->name) {
        PyErr_SetString(libftdb_ftdbError, "No 'name' field in type entry");
        return 0;
    }

    return PyUnicode_FromString(__self->entry->name);
}

PyObject* libftdb_ftdb_type_entry_get_is_dependent(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if ((__self->entry->isdependent) && (*__self->entry->isdependent)) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_type_entry_get_globalrefs(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if (!__self->entry->globalrefs) {
        PyErr_SetString(libftdb_ftdbError, "No 'globalrefs' field in type entry");
        return 0;
    }

    PyObject* globalrefs = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->globalrefs_count; ++i) {
        PYLIST_ADD_ULONG(globalrefs,__self->entry->globalrefs[i]);
    }
    return globalrefs;
}

PyObject* libftdb_ftdb_type_entry_get_enumvalues(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if (!__self->entry->enumvalues) {
        PyErr_SetString(libftdb_ftdbError, "No 'enumvalues' field in type entry");
        return 0;
    }

    PyObject* enumvalues = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->enumvalues_count; ++i) {
        PYLIST_ADD_LONG(enumvalues,__self->entry->enumvalues[i]);
    }
    return enumvalues;
}

PyObject* libftdb_ftdb_type_entry_get_outerfn(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if (!__self->entry->outerfn) {
        PyErr_SetString(libftdb_ftdbError, "No 'outerfn' field in type entry");
        return 0;
    }

    return PyUnicode_FromString(__self->entry->outerfn);
}

PyObject* libftdb_ftdb_type_entry_get_outerfnid(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if (!__self->entry->outerfnid) {
        PyErr_SetString(libftdb_ftdbError, "No 'outerfnid' field in type entry");
        return 0;
    }

    return PyLong_FromUnsignedLong(*__self->entry->outerfnid);
}

PyObject* libftdb_ftdb_type_entry_get_is_implicit(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if ((__self->entry->isimplicit) && (*__self->entry->isimplicit)) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_type_entry_get_is_union(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if ((__self->entry->isunion) && (*__self->entry->isunion)) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_type_entry_get_refnames(PyObject* self, void* closure) {

    static char errmsg[ERRMSG_BUFFER_SIZE];
    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if (!__self->entry->refnames) {
        snprintf(errmsg,ERRMSG_BUFFER_SIZE,"No 'refnames' field in type entry ([%lu])\n",__self->entry->refnames_count);
        PyErr_SetString(libftdb_ftdbError, errmsg);
        return 0;
    }

    PyObject* refnames = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->refnames_count; ++i) {
        PYLIST_ADD_STRING(refnames,__self->entry->refnames[i]);
    }
    return refnames;
}

PyObject* libftdb_ftdb_type_entry_get_location(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if (!__self->entry->location) {
        PyErr_SetString(libftdb_ftdbError, "No 'location' field in type entry");
        return 0;
    }

    return PyUnicode_FromString(__self->entry->location);
}

PyObject* libftdb_ftdb_type_entry_get_is_variadic(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if ((__self->entry->isvariadic) && (*__self->entry->isvariadic)) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_type_entry_get_funrefs(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if (!__self->entry->funrefs) {
        PyErr_SetString(libftdb_ftdbError, "No 'funrefs' field in type entry");
        return 0;
    }

    PyObject* funrefs = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->funrefs_count; ++i) {
        PYLIST_ADD_ULONG(funrefs,__self->entry->funrefs[i]);
    }
    return funrefs;
}

PyObject* libftdb_ftdb_type_entry_get_useddef(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if (!__self->entry->useddef) {
        PyErr_SetString(libftdb_ftdbError, "No 'useddef' field in type entry");
        return 0;
    }

    PyObject* useddef = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->useddef_count; ++i) {
        PYLIST_ADD_STRING(useddef,__self->entry->useddef[i]);
    }
    return useddef;
}

PyObject* libftdb_ftdb_type_entry_get_defhead(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if (!__self->entry->defhead) {
        PyErr_SetString(libftdb_ftdbError, "No 'defhead' field in type entry");
        return 0;
    }

    return PyUnicode_FromString(__self->entry->defhead);
}

PyObject* libftdb_ftdb_type_entry_get_identifiers(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if (!__self->entry->identifiers) {
        PyErr_SetString(libftdb_ftdbError, "No 'identifiers' field in type entry");
        return 0;
    }

    PyObject* identifiers = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->identifiers_count; ++i) {
        PYLIST_ADD_STRING(identifiers,__self->entry->identifiers[i]);
    }
    return identifiers;
}

PyObject* libftdb_ftdb_type_entry_get_methods(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if (!__self->entry->methods) {
        PyErr_SetString(libftdb_ftdbError, "No 'methods' field in type entry");
        return 0;
    }

    PyObject* methods = PyList_New(0);
    for (unsigned long i=0; i<__self->entry->methods_count; ++i) {
        PYLIST_ADD_ULONG(methods,__self->entry->methods[i]);
    }
    return methods;
}

PyObject* libftdb_ftdb_type_entry_get_bitfields(PyObject* self, void* closure) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if (!__self->entry->bitfields) {
        PyErr_SetString(libftdb_ftdbError, "No 'bitfields' field in type entry");
        return 0;
    }

    PyObject* bitfields = PyDict_New();
    for (unsigned long i=0; i<__self->entry->bitfields_count; ++i) {
        struct bitfield* bitfield = &__self->entry->bitfields[i];
        PyObject* py_bkey = PyUnicode_FromFormat("%lu",bitfield->index);
        PyObject* py_bval = PyLong_FromUnsignedLong(bitfield->bitwidth);
        PyDict_SetItem(bitfields,py_bkey,py_bval);
        Py_DecRef(py_bkey);
        Py_DecRef(py_bval);
    }
    return bitfields;
}

PyObject* libftdb_ftdb_type_entry_has_usedrefs(libftdb_ftdb_type_entry_object *self, PyObject *args) {

    if (self->entry->usedrefs) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_type_entry_has_decls(libftdb_ftdb_type_entry_object *self, PyObject *args) {

    if (self->entry->decls) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_type_entry_has_attrs(libftdb_ftdb_type_entry_object *self, PyObject *args) {

    if ((self->entry->attrnum) && (*self->entry->attrnum>0)) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_type_entry_has_outerfn(libftdb_ftdb_type_entry_object *self, PyObject *args) {

    if (self->entry->outerfn) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

PyObject* libftdb_ftdb_type_entry_has_location(libftdb_ftdb_type_entry_object *self, PyObject *args) {

    if (self->entry->location) {
        Py_RETURN_TRUE;
    }

    Py_RETURN_FALSE;
}

static int libftdb_ftdb_type_entry_is_const_internal_type(struct ftdb_type_entry* entry) {

    const char* c = entry->qualifiers;
    while(*c) {
        if (*c++=='c') return 1;
    }
    return 0;
}

static int libftdb_ftdb_type_entry_is_const_internal(libftdb_ftdb_type_entry_object *self) {

    const char* c = self->entry->qualifiers;
    while(*c) {
        if (*c++=='c') return 1;
    }
    return 0;
}

PyObject* libftdb_ftdb_type_entry_is_const(libftdb_ftdb_type_entry_object *self, PyObject *args) {

    if (libftdb_ftdb_type_entry_is_const_internal(self)) {
        Py_RETURN_TRUE;
    }
    Py_RETURN_FALSE;
}

static inline const char* __real_hash(const char* hash) {

    int coln = 0;
    while(*hash) {
        if (*hash++==':') coln++;
        if (coln>=2) break;
    }
    return hash;
}

PyObject* libftdb_ftdb_type_entry_to_non_const(libftdb_ftdb_type_entry_object *self, PyObject *args) {

    if (!libftdb_ftdb_type_entry_is_const_internal(self)) {
        Py_IncRef((PyObject*)self);
        return (PyObject*)self;
    }

    for (unsigned long i=0; i<self->types->ftdb->types_count; ++i) {
        struct ftdb_type_entry* entry = &self->types->ftdb->types[i];
        if (strcmp(self->entry->str,entry->str)) continue;
        if (entry->__class==TYPECLASS_RECORDFORWARD) continue;
        if (strcmp(__real_hash(self->entry->hash),__real_hash(entry->hash))) continue;
        if (libftdb_ftdb_type_entry_is_const_internal_type(entry)) continue;
        PyObject* args = PyTuple_New(2);
        PYTUPLE_SET_ULONG(args,0,(uintptr_t)self->types);
        PYTUPLE_SET_ULONG(args,1,entry->__index);
        PyObject *py_entry = PyObject_CallObject((PyObject *) &libftdb_ftdbTypeEntryType, args);
        Py_DecRef(args);
        return py_entry;
    }

    Py_IncRef((PyObject*)self);
    return (PyObject*)self;
}

PyObject* libftdb_ftdb_type_entry_mp_subscript(PyObject* self, PyObject* slice) {

    static char errmsg[ERRMSG_BUFFER_SIZE];

    if (!PyUnicode_Check(slice)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in property mapping (not a str)");
        Py_RETURN_NONE;
    }

    const char* attr = PyString_get_c_str(slice);

    if (!strcmp(attr,"id")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_id(self,0);
    }
    else if (!strcmp(attr,"fid")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_fid(self,0);
    }
    else if (!strcmp(attr,"hash")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_hash(self,0);
    }
    else if (!strcmp(attr,"class")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_classname(self,0);
    }
    else if (!strcmp(attr,"classid")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_classid(self,0);
    }
    else if (!strcmp(attr,"qualifiers")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_qualifiers(self,0);
    }
    else if (!strcmp(attr,"size")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_size(self,0);
    }
    else if (!strcmp(attr,"str")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_str(self,0);
    }
    else if (!strcmp(attr,"refcount")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_refcount(self,0);
    }
    else if (!strcmp(attr,"refs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_refs(self,0);
    }
    else if (!strcmp(attr,"usedrefs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_usedrefs(self,0);
    }
    else if (!strcmp(attr,"decls")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_decls(self,0);
    }
    else if (!strcmp(attr,"def")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_def(self,0);
    }
    else if (!strcmp(attr,"memberoffsets")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_memberoffsets(self,0);
    }
    else if (!strcmp(attr,"attrrefs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_attrrefs(self,0);
    }
    else if (!strcmp(attr,"attrnum")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_attrnum(self,0);
    }
    else if (!strcmp(attr,"name")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_name(self,0);
    }
    else if (!strcmp(attr,"dependent")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_is_dependent(self,0);
    }
    else if (!strcmp(attr,"globalrefs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_globalrefs(self,0);
    }
    else if (!strcmp(attr,"values")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_enumvalues(self,0);
    }
    else if (!strcmp(attr,"outerfn")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_outerfn(self,0);
    }
    else if (!strcmp(attr,"outerfnid")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_outerfnid(self,0);
    }
    else if (!strcmp(attr,"implicit")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_is_implicit(self,0);
    }
    else if (!strcmp(attr,"union")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_is_union(self,0);
    }
    else if (!strcmp(attr,"refnames")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_refnames(self,0);
    }
    else if (!strcmp(attr,"location")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_location(self,0);
    }
    else if (!strcmp(attr,"variadic")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_is_variadic(self,0);
    }
    else if (!strcmp(attr,"funrefs")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_funrefs(self,0);
    }
    else if (!strcmp(attr,"useddef")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_useddef(self,0);
    }
    else if (!strcmp(attr,"defhead")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_defhead(self,0);
    }
    else if (!strcmp(attr,"identifiers")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_identifiers(self,0);
    }
    else if (!strcmp(attr,"methods")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_methods(self,0);
    }
    else if (!strcmp(attr,"bitfields")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_type_entry_get_bitfields(self,0);
    }

    snprintf(errmsg,ERRMSG_BUFFER_SIZE,"Invalid attribute name: %s",attr);
    PyErr_SetString(libftdb_ftdbError, errmsg);
    PYASSTR_DECREF(attr);
    Py_RETURN_NONE;
}

int libftdb_ftdb_type_entry_sq_contains(PyObject* self, PyObject* key) {

    if (!PyUnicode_Check(key)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in contains check (not a str)");
        return 0;
    }

    const char* attr = PyString_get_c_str(key);
    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;

    if (!strcmp(attr,"id")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"fid")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"hash")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"class")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"classid")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"qualifiers")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"size")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"str")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"refcount")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"refs")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"usedrefs")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->usedrefs;
    }
    else if (!strcmp(attr,"decls")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->decls;
    }
    else if (!strcmp(attr,"def")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->def;
    }
    else if (!strcmp(attr,"memberoffsets")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->memberoffsets;
    }
    else if (!strcmp(attr,"attrrefs")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->attrrefs;
    }
    else if (!strcmp(attr,"attrnum")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->attrnum;
    }
    else if (!strcmp(attr,"name")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->name;
    }
    else if (!strcmp(attr,"dependent")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->isdependent;
    }
    else if (!strcmp(attr,"globalrefs")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->globalrefs;
    }
    else if (!strcmp(attr,"values")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->enumvalues;
    }
    else if (!strcmp(attr,"outerfn")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->outerfn;
    }
    else if (!strcmp(attr,"outerfnid")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->outerfnid;
    }
    else if (!strcmp(attr,"implicit")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->isimplicit;
    }
    else if (!strcmp(attr,"union")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->isunion;
    }
    else if (!strcmp(attr,"refnames")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->refnames;
    }
    else if (!strcmp(attr,"location")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->location;
    }
    else if (!strcmp(attr,"variadic")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->isvariadic;
    }
    else if (!strcmp(attr,"funrefs")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->funrefs;
    }
    else if (!strcmp(attr,"useddef")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->useddef;
    }
    else if (!strcmp(attr,"defhead")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->defhead;
    }
    else if (!strcmp(attr,"identifiers")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->identifiers;
    }
    else if (!strcmp(attr,"methods")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->methods;
    }
    else if (!strcmp(attr,"bitfields")) {
        PYASSTR_DECREF(attr);
        return !!__self->entry->bitfields;
    }

    PYASSTR_DECREF(attr);
    return 0;
}

PyObject* libftdb_ftdb_type_entry_deepcopy(PyObject* self, PyObject* memo) {

    Py_INCREF(self);
    return (PyObject *)self;
}

Py_hash_t libftdb_ftdb_type_entry_hash(PyObject *o) {

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)o;
    return __self->index;
}

PyObject* libftdb_ftdb_type_entry_richcompare(PyObject *self, PyObject *other, int op) {

    if (!PyObject_IsInstance(other, (PyObject *)&libftdb_ftdbTypeEntryType))
        Py_RETURN_FALSE;

    libftdb_ftdb_type_entry_object* __self = (libftdb_ftdb_type_entry_object*)self;
    libftdb_ftdb_type_entry_object* __other = (libftdb_ftdb_type_entry_object*)other;
    Py_RETURN_RICHCOMPARE_internal(__self->index, __other->index , op);
}

PyObject* libftdb_ftdb_type_entry_json(libftdb_ftdb_type_entry_object *self, PyObject *args) {

    PyObject* json_entry = PyDict_New();

    FTDB_SET_ENTRY_ULONG(json_entry,id,self->entry->id);
    FTDB_SET_ENTRY_ULONG(json_entry,fid,self->entry->fid);
    FTDB_SET_ENTRY_STRING(json_entry,hash,self->entry->hash);
    FTDB_SET_ENTRY_STRING(json_entry,class,self->entry->class_name);
    FTDB_SET_ENTRY_STRING(json_entry,qualifiers,self->entry->qualifiers);
    FTDB_SET_ENTRY_ULONG(json_entry,size,self->entry->size);
    FTDB_SET_ENTRY_STRING(json_entry,str,self->entry->str);
    FTDB_SET_ENTRY_ULONG(json_entry,refcount,self->entry->refcount);
    FTDB_SET_ENTRY_ULONG_ARRAY(json_entry,refs,self->entry->refs);
    FTDB_SET_ENTRY_INT64_ARRAY_OPTIONAL(json_entry,usedrefs,self->entry->usedrefs);
    FTDB_SET_ENTRY_ULONG_ARRAY_OPTIONAL(json_entry,decls,self->entry->decls);
    FTDB_SET_ENTRY_STRING_OPTIONAL(json_entry,def,self->entry->def);
    FTDB_SET_ENTRY_ULONG_ARRAY_OPTIONAL(json_entry,memberoffsets,self->entry->memberoffsets);
    FTDB_SET_ENTRY_ULONG_ARRAY_OPTIONAL(json_entry,attrrefs,self->entry->attrrefs);
    FTDB_SET_ENTRY_ULONG_OPTIONAL(json_entry,attrnum,self->entry->attrnum);
    FTDB_SET_ENTRY_STRING_OPTIONAL(json_entry,name,self->entry->name);
    FTDB_SET_ENTRY_BOOL_OPTIONAL(json_entry,dependent,self->entry->isdependent);
    FTDB_SET_ENTRY_ULONG_ARRAY_OPTIONAL(json_entry,globalrefs,self->entry->globalrefs);
    FTDB_SET_ENTRY_INT64_ARRAY_OPTIONAL(json_entry,values,self->entry->enumvalues);
    FTDB_SET_ENTRY_STRING_OPTIONAL(json_entry,outerfn,self->entry->outerfn);
    FTDB_SET_ENTRY_ULONG_OPTIONAL(json_entry,outerfnid,self->entry->outerfnid);
    FTDB_SET_ENTRY_BOOL_OPTIONAL(json_entry,implicit,self->entry->isimplicit);
    FTDB_SET_ENTRY_BOOL_OPTIONAL(json_entry,union,self->entry->isunion);
    FTDB_SET_ENTRY_STRING_ARRAY_OPTIONAL(json_entry,refnames,self->entry->refnames);
    FTDB_SET_ENTRY_STRING_OPTIONAL(json_entry,location,self->entry->location);
    FTDB_SET_ENTRY_INT_OPTIONAL(json_entry,variadic,self->entry->isvariadic);
    FTDB_SET_ENTRY_ULONG_ARRAY_OPTIONAL(json_entry,funrefs,self->entry->funrefs);
    FTDB_SET_ENTRY_STRING_ARRAY_OPTIONAL(json_entry,useddef,self->entry->useddef);
    FTDB_SET_ENTRY_STRING_OPTIONAL(json_entry,defhead,self->entry->defhead);
    FTDB_SET_ENTRY_STRING_ARRAY_OPTIONAL(json_entry,identifiers,self->entry->identifiers);
    FTDB_SET_ENTRY_ULONG_ARRAY_OPTIONAL(json_entry,methods,self->entry->methods);

    if (self->entry->bitfields) {
        PyObject* bitfields = PyDict_New();
        for (unsigned long i=0; i<self->entry->bitfields_count; ++i) {
            struct bitfield* bitfield = &self->entry->bitfields[i];
            PyObject* py_bkey = PyUnicode_FromFormat("%lu",bitfield->index);
            PyObject* py_bval = PyLong_FromUnsignedLong(bitfield->bitwidth);
            PyDict_SetItem(bitfields,py_bkey,py_bval);
            Py_DecRef(py_bkey);
            Py_DecRef(py_bval);
        }
        FTDB_SET_ENTRY_PYOBJECT(json_entry,bitfields,bitfields);
    }

    return json_entry;
}

void libftdb_ftdb_fops_dealloc(libftdb_ftdb_fops_object* self) {

    Py_DecRef((PyObject*)self->py_ftdb);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_fops_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    libftdb_ftdb_fops_object* self;

    self = (libftdb_ftdb_fops_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->ftdb = (const struct ftdb*)PyLong_AsLong(PyTuple_GetItem(args,0));
        self->py_ftdb = (const libftdb_ftdb_object*)PyLong_AsLong(PyTuple_GetItem(args,1));
        Py_IncRef((PyObject*)self->py_ftdb);
    }

    return (PyObject *)self;
}

PyObject* libftdb_ftdb_fops_repr(PyObject* self) {

    static char repr[1024];

    libftdb_ftdb_fops_object* __self = (libftdb_ftdb_fops_object*)self;
    int written = snprintf(repr,1024,"<ftdbFops object at %lx : ",(uintptr_t)self);
    written+=snprintf(repr+written,1024-written,"%ld fops variables>",__self->ftdb->fops_count);

    return PyUnicode_FromString(repr);
}

Py_ssize_t libftdb_ftdb_fops_sq_length(PyObject* self) {

    libftdb_ftdb_fops_object* __self = (libftdb_ftdb_fops_object*)self;
    return __self->ftdb->fops_count;
}

PyObject* libftdb_ftdb_fops_getiter(PyObject* self) {

    libftdb_ftdb_fops_object* __self = (libftdb_ftdb_fops_object*)self;

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
    PYTUPLE_SET_ULONG(args,1,0);
    PyObject *iter = PyObject_CallObject((PyObject *) &libftdb_ftdbFopsIterType, args);

    Py_DecRef(args);
    return iter;
}

PyObject* libftdb_ftdb_fops_mp_subscript(PyObject* self, PyObject* slice) {

    libftdb_ftdb_fops_object* __self = (libftdb_ftdb_fops_object*)self;

    if ((!PyLong_Check(slice))) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type fops index (not an (integer))");
        Py_RETURN_NONE;
    }

    unsigned long index = PyLong_AsLong(slice);

    if (index >= __self->ftdb->fops_count) {
        /* Raising of standard StopIteration exception with empty value. */
        PyErr_SetString(libftdb_ftdbError, "fops index out of range");
        Py_RETURN_NONE;
    }

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self);
    PYTUPLE_SET_ULONG(args,1,index);
    PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFopsEntryType, args);
    Py_DecRef(args);
    return entry;
}

void libftdb_ftdb_fops_iter_dealloc(libftdb_ftdb_fops_iter_object* self) {

    Py_DecRef((PyObject*)self->fops);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_fops_iter_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    libftdb_ftdb_fops_iter_object* self;

    self = (libftdb_ftdb_fops_iter_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->fops = (libftdb_ftdb_fops_object*)PyLong_AsLong(PyTuple_GetItem(args,0));
        Py_IncRef((PyObject*)self->fops);
        self->index = PyLong_AsLong(PyTuple_GetItem(args,1));
    }

    return (PyObject *)self;
}

Py_ssize_t libftdb_ftdb_fops_iter_sq_length(PyObject* self) {

    libftdb_ftdb_fops_iter_object* __self = (libftdb_ftdb_fops_iter_object*)self;
    return __self->fops->ftdb->fops_count;
}

PyObject* libftdb_ftdb_fops_iter_next(PyObject *self) {

    libftdb_ftdb_fops_iter_object* __self = (libftdb_ftdb_fops_iter_object*)self;

    if (__self->index >= __self->fops->ftdb->fops_count) {
        /* Raising of standard StopIteration exception with empty value. */
        PyErr_SetNone(PyExc_StopIteration);
        return 0;
    }

    PyObject* args = PyTuple_New(2);
    PYTUPLE_SET_ULONG(args,0,(uintptr_t)__self->fops);
    PYTUPLE_SET_ULONG(args,1,__self->index);
    PyObject *entry = PyObject_CallObject((PyObject *) &libftdb_ftdbFopsEntryType, args);
    Py_DecRef(args);
    __self->index++;
    return entry;
}

void libftdb_ftdb_fops_entry_dealloc(libftdb_ftdb_fops_entry_object* self) {

    Py_DecRef((PyObject*)self->fops);
    PyTypeObject *tp = Py_TYPE(self);
    tp->tp_free(self);
}

PyObject* libftdb_ftdb_fops_entry_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) {

    libftdb_ftdb_fops_entry_object* self;

    self = (libftdb_ftdb_fops_entry_object*)subtype->tp_alloc(subtype, 0);
    if (self != 0) {
        self->fops = (const libftdb_ftdb_fops_object*)PyLong_AsLong(PyTuple_GetItem(args,0));
        Py_IncRef((PyObject*)self->fops);
        unsigned long index = PyLong_AsLong(PyTuple_GetItem(args,1));
        if (index>=self->fops->ftdb->fops_count) {
            PyErr_SetString(libftdb_ftdbError, "fops entry index out of bounds");
            return 0;
        }
        self->index = index;
        self->entry = &self->fops->ftdb->fops[self->index];
    }

    return (PyObject *)self;
}

PyObject* libftdb_ftdb_fops_entry_repr(PyObject* self) {

    static char repr[1024];

    libftdb_ftdb_fops_entry_object* __self = (libftdb_ftdb_fops_entry_object*)self;
    int written = snprintf(repr,1024,"<ftdbFopsEntry object at %lx : ",(uintptr_t)__self);
    (void)written;

    return PyUnicode_FromString(repr);
}

PyObject* libftdb_ftdb_fops_entry_json(libftdb_ftdb_fops_entry_object *self, PyObject *args) {

    PyObject* json_entry = PyDict_New();

    FTDB_SET_ENTRY_ENUM_TO_STRING(json_entry,kind,self->entry->kind,fopsKind);
    FTDB_SET_ENTRY_ULONG(json_entry,type,self->entry->type_id);
    FTDB_SET_ENTRY_ULONG(json_entry,var,self->entry->var_id);
    FTDB_SET_ENTRY_ULONG(json_entry,func,self->entry->func_id);
    FTDB_SET_ENTRY_STRING(json_entry,loc,self->entry->location);
    PyObject* members = PyDict_New();
    for (unsigned long i=0; i<self->entry->members_count; ++i) {
        struct ftdb_fops_member_entry* fops_member_info = &self->entry->members[i];
        PyObject* py_member = PyUnicode_FromFormat("%lu",fops_member_info->member_id);
        PyObject* py_func_ids = PyList_New(0);
        for(unsigned long j=0; j<fops_member_info->func_ids_count; j++){
            PYLIST_ADD_ULONG(py_func_ids,fops_member_info->func_ids[j]);
        }
        PyDict_SetItem(members,py_member,py_func_ids);
        Py_DecRef(py_member);
        Py_DecRef(py_func_ids);
    }
    FTDB_SET_ENTRY_PYOBJECT(json_entry,members,members);

    return json_entry;
}

PyObject* libftdb_ftdb_fops_entry_get_kind(PyObject* self, void* closure) {

    libftdb_ftdb_fops_entry_object* __self = (libftdb_ftdb_fops_entry_object*)self;
    return PyUnicode_FromString(set_fopsKind(__self->entry->kind));
}

PyObject* libftdb_ftdb_fops_entry_get_type(PyObject* self, void* closure) {

    libftdb_ftdb_fops_entry_object* __self = (libftdb_ftdb_fops_entry_object*)self;
    return PyLong_FromUnsignedLong(__self->entry->type_id);
}

PyObject* libftdb_ftdb_fops_entry_get_var(PyObject* self, void* closure) {

    libftdb_ftdb_fops_entry_object* __self = (libftdb_ftdb_fops_entry_object*)self;
    return PyLong_FromUnsignedLong(__self->entry->var_id);
}

PyObject* libftdb_ftdb_fops_entry_get_func(PyObject* self, void* closure) {

    libftdb_ftdb_fops_entry_object* __self = (libftdb_ftdb_fops_entry_object*)self;
    return PyLong_FromUnsignedLong(__self->entry->func_id);
}


PyObject* libftdb_ftdb_fops_entry_get_members(PyObject* self, void* closure) {

    libftdb_ftdb_fops_entry_object* __self = (libftdb_ftdb_fops_entry_object*)self;

    PyObject* members = PyDict_New();
    for (unsigned long i=0; i<__self->entry->members_count; ++i) {
        struct ftdb_fops_member_entry* fops_member_info = &__self->entry->members[i];
        PyObject* py_member = PyUnicode_FromFormat("%lu",fops_member_info->member_id);
        PyObject* py_func_ids = PyList_New(0);
        for(unsigned long j=0; j<fops_member_info->func_ids_count; j++){
            PyObject* py_fnid = PyLong_FromUnsignedLong(fops_member_info->func_ids[j]);
            PyList_Append(py_func_ids,py_fnid);
            Py_DecRef(py_fnid);
        }
        PyDict_SetItem(members,py_member,py_func_ids);
        Py_DecRef(py_member);
    }
    return members;
}

PyObject* libftdb_ftdb_fops_entry_get_location(PyObject* self, void* closure) {

    libftdb_ftdb_fops_entry_object* __self = (libftdb_ftdb_fops_entry_object*)self;
    return PyUnicode_FromString(__self->entry->location);
}

PyObject* libftdb_ftdb_fops_entry_mp_subscript(PyObject* self, PyObject* slice) {

    static char errmsg[ERRMSG_BUFFER_SIZE];

    if (!PyUnicode_Check(slice)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in property mapping (not a str)");
        Py_RETURN_NONE;
    }

    const char* attr = PyString_get_c_str(slice);

    if (!strcmp(attr,"kind")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_fops_entry_get_kind(self,0);
    }
    if (!strcmp(attr,"type")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_fops_entry_get_type(self,0);
    }
    if (!strcmp(attr,"var")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_fops_entry_get_var(self,0);
    }
    if (!strcmp(attr,"func")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_fops_entry_get_func(self,0);
    }
    else if (!strcmp(attr,"members")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_fops_entry_get_members(self,0);
    }
    else if (!strcmp(attr,"loc")) {
        PYASSTR_DECREF(attr);
        return libftdb_ftdb_fops_entry_get_location(self,0);
    }

    snprintf(errmsg,ERRMSG_BUFFER_SIZE,"Invalid attribute name: %s",attr);
    PyErr_SetString(libftdb_ftdbError, errmsg);
    PYASSTR_DECREF(attr);
    Py_RETURN_NONE;
}

int libftdb_ftdb_fops_entry_sq_contains(PyObject* self, PyObject* key) {

    if (!PyUnicode_Check(key)) {
        PyErr_SetString(libftdb_ftdbError, "Invalid type in contains check (not a str)");
        return 0;
    }

    const char* attr = PyString_get_c_str(key);

    if (!strcmp(attr,"type")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"var")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"func")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"kind")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"members")) {
        PYASSTR_DECREF(attr);
        return 1;
    }
    else if (!strcmp(attr,"loc")) {
        PYASSTR_DECREF(attr);
        return 1;
    }

    PYASSTR_DECREF(attr);
    return 0;
}

PyObject* libftdb_ftdb_fops_entry_deepcopy(PyObject* self, PyObject* memo) {

    Py_INCREF(self);
    return (PyObject *)self;
}

FUNCTION_DECLARE_FLATTEN_STRUCT(stringRefMap_node);

FUNCTION_DEFINE_FLATTEN_STRUCT(stringRefMap_node,
    AGGREGATE_FLATTEN_STRUCT_EMBEDDED_POINTER(stringRefMap_node,node.__rb_parent_color,
            ptr_clear_2lsb_bits,flatten_ptr_restore_2lsb_bits);
    AGGREGATE_FLATTEN_STRUCT(stringRefMap_node,node.rb_right);
    AGGREGATE_FLATTEN_STRUCT(stringRefMap_node,node.rb_left);
    AGGREGATE_FLATTEN_STRING(key);
);

FUNCTION_DECLARE_FLATTEN_STRUCT(ftdb);
FUNCTION_DECLARE_FLATTEN_STRUCT(ftdb_func_entry);
FUNCTION_DECLARE_FLATTEN_STRUCT(ftdb_funcdecl_entry);
FUNCTION_DECLARE_FLATTEN_STRUCT(ftdb_unresolvedfunc_entry);
FUNCTION_DECLARE_FLATTEN_STRUCT(taint_element);
FUNCTION_DECLARE_FLATTEN_STRUCT(taint_data);
FUNCTION_DECLARE_FLATTEN_STRUCT(call_info);
FUNCTION_DECLARE_FLATTEN_STRUCT(callref_info);
FUNCTION_DECLARE_FLATTEN_STRUCT(callref_data);
FUNCTION_DECLARE_FLATTEN_STRUCT(refcall);
FUNCTION_DECLARE_FLATTEN_STRUCT(switch_info);
FUNCTION_DECLARE_FLATTEN_STRUCT(case_info);
FUNCTION_DECLARE_FLATTEN_STRUCT(case_data);
FUNCTION_DECLARE_FLATTEN_STRUCT(csitem);
FUNCTION_DECLARE_FLATTEN_STRUCT(mexp_info);
FUNCTION_DECLARE_FLATTEN_STRUCT(local_info);
FUNCTION_DECLARE_FLATTEN_STRUCT(deref_info);
FUNCTION_DECLARE_FLATTEN_STRUCT(offsetref_info);
FUNCTION_DECLARE_FLATTEN_STRUCT(if_info);
FUNCTION_DECLARE_FLATTEN_STRUCT(ifref_info);
FUNCTION_DECLARE_FLATTEN_STRUCT(asm_info);
FUNCTION_DECLARE_FLATTEN_STRUCT(globalref_data);
FUNCTION_DECLARE_FLATTEN_STRUCT(globalref_info);
FUNCTION_DECLARE_FLATTEN_STRUCT(ftdb_global_entry);
FUNCTION_DECLARE_FLATTEN_STRUCT(ftdb_type_entry);
FUNCTION_DECLARE_FLATTEN_STRUCT(ftdb_fops_entry);
FUNCTION_DECLARE_FLATTEN_STRUCT(ftdb_fops_member_entry);
FUNCTION_DECLARE_FLATTEN_STRUCT(bitfield);
FUNCTION_DECLARE_FLATTEN_STRUCT(func_fptrs_item);


FUNCTION_DEFINE_FLATTEN_STRUCT(taint_data,
    AGGREGATE_FLATTEN_STRUCT_ARRAY(taint_element,taint_list,ATTR(taint_list_count));
);

FUNCTION_DEFINE_FLATTEN_STRUCT(taint_element,
    /* No recipes needed */
);

FUNCTION_DEFINE_FLATTEN_STRUCT(call_info,
    AGGREGATE_FLATTEN_STRING(start);
    AGGREGATE_FLATTEN_STRING(end);
    AGGREGATE_FLATTEN_STRING(expr);
    AGGREGATE_FLATTEN_STRING(loc);
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,args,ATTR(args_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(int64_t,csid,1);
);

FUNCTION_DEFINE_FLATTEN_STRUCT(callref_info,
    AGGREGATE_FLATTEN_STRUCT_ARRAY(callref_data,callarg,ATTR(callarg_count));
);

FUNCTION_DEFINE_FLATTEN_STRUCT(callref_data,
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,id,1);
    AGGREGATE_FLATTEN_TYPE_ARRAY(int64_t,integer_literal,1);
    AGGREGATE_FLATTEN_TYPE_ARRAY(int,character_literal,1);
    AGGREGATE_FLATTEN_TYPE_ARRAY(double,floating_literal,1);
    AGGREGATE_FLATTEN_STRING(string_literal);
);

FUNCTION_DEFINE_FLATTEN_STRUCT(refcall,
    /* No recipes needed */
);

FUNCTION_DEFINE_FLATTEN_STRUCT(switch_info,
    AGGREGATE_FLATTEN_STRING(condition);
    AGGREGATE_FLATTEN_STRUCT_ARRAY(case_info,cases,ATTR(cases_count));
);

FUNCTION_DEFINE_FLATTEN_STRUCT(case_info,
    AGGREGATE_FLATTEN_STRING(lhs.enum_code);
    AGGREGATE_FLATTEN_STRING(lhs.macro_code);
    AGGREGATE_FLATTEN_STRING(lhs.raw_code);
    AGGREGATE_FLATTEN_STRUCT_ARRAY(case_data,rhs,1);
);

FUNCTION_DEFINE_FLATTEN_STRUCT(case_data,
    AGGREGATE_FLATTEN_STRING(enum_code);
    AGGREGATE_FLATTEN_STRING(macro_code);
    AGGREGATE_FLATTEN_STRING(raw_code);
);

FUNCTION_DEFINE_FLATTEN_STRUCT(csitem,
        AGGREGATE_FLATTEN_STRING(cf);
);

FUNCTION_DEFINE_FLATTEN_STRUCT(mexp_info,
        AGGREGATE_FLATTEN_STRING(text);
);

FUNCTION_DEFINE_FLATTEN_STRUCT(local_info,
    AGGREGATE_FLATTEN_STRING(name);
    AGGREGATE_FLATTEN_TYPE_ARRAY(int64_t,csid,1);
    AGGREGATE_FLATTEN_STRING(location);
);

FUNCTION_DEFINE_FLATTEN_STRUCT(deref_info,
    AGGREGATE_FLATTEN_TYPE_ARRAY(int64_t,offset,1);
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,basecnt,1);
    AGGREGATE_FLATTEN_STRUCT_ARRAY(offsetref_info,offsetrefs,ATTR(offsetrefs_count));
    AGGREGATE_FLATTEN_STRING(expr);
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,ord,ATTR(ord_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(int64_t,member,ATTR(member_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,type,ATTR(type_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,access,ATTR(access_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(int64_t,shift,ATTR(shift_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(int64_t,mcall,ATTR(mcall_count));
);

FUNCTION_DEFINE_FLATTEN_STRUCT(offsetref_info,
    if (ATTR(kind)==EXPR_STRING) {
        AGGREGATE_FLATTEN_STRING(id_string);
    }
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,mi,1);
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,di,1);
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,cast,1);
);

FUNCTION_DEFINE_FLATTEN_STRUCT(if_info,
    AGGREGATE_FLATTEN_STRUCT_ARRAY(ifref_info,refs,ATTR(refs_count));
);

FUNCTION_DEFINE_FLATTEN_STRUCT(ifref_info,
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,id,1);
    AGGREGATE_FLATTEN_TYPE_ARRAY(int64_t,integer_literal,1);
    AGGREGATE_FLATTEN_TYPE_ARRAY(int,character_literal,1);
    AGGREGATE_FLATTEN_TYPE_ARRAY(double,floating_literal,1);
    AGGREGATE_FLATTEN_STRING(string_literal);
);

FUNCTION_DEFINE_FLATTEN_STRUCT(asm_info,
    AGGREGATE_FLATTEN_STRING(str);
);

FUNCTION_DEFINE_FLATTEN_STRUCT(globalref_data,
    AGGREGATE_FLATTEN_STRUCT_ARRAY(globalref_info,refs,ATTR(refs_count));
);

FUNCTION_DEFINE_FLATTEN_STRUCT(globalref_info,
    AGGREGATE_FLATTEN_STRING(start);
    AGGREGATE_FLATTEN_STRING(end);
);

FUNCTION_DECLARE_FLATTEN_STRUCT_TYPE(ftdb_ulong_type_entryMap);
FUNCTION_DECLARE_FLATTEN_STRUCT_TYPE(ftdb_ulong_func_entryMap);
FUNCTION_DECLARE_FLATTEN_STRUCT_TYPE(ftdb_ulong_funcdecl_entryMap);
FUNCTION_DECLARE_FLATTEN_STRUCT_TYPE(ftdb_ulong_global_entryMap);
FUNCTION_DECLARE_FLATTEN_STRUCT_TYPE(ftdb_ulong_static_funcs_map_entryMap);


FUNCTION_DEFINE_FLATTEN_STRUCT_TYPE(ftdb_ulong_type_entryMap,
    AGGREGATE_FLATTEN_STRUCT_TYPE_EMBEDDED_POINTER(ftdb_ulong_type_entryMap,node.__rb_parent_color,
            ptr_clear_2lsb_bits,flatten_ptr_restore_2lsb_bits);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_ulong_type_entryMap,node.rb_right);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_ulong_type_entryMap,node.rb_left);
    AGGREGATE_FLATTEN_STRUCT(ftdb_type_entry,entry);
);

FUNCTION_DEFINE_FLATTEN_STRUCT_TYPE(ftdb_ulong_func_entryMap,
    AGGREGATE_FLATTEN_STRUCT_TYPE_EMBEDDED_POINTER(ftdb_ulong_func_entryMap,node.__rb_parent_color,
            ptr_clear_2lsb_bits,flatten_ptr_restore_2lsb_bits);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_ulong_func_entryMap,node.rb_right);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_ulong_func_entryMap,node.rb_left);
    AGGREGATE_FLATTEN_STRUCT(ftdb_func_entry,entry);
);

FUNCTION_DEFINE_FLATTEN_STRUCT_TYPE(ftdb_ulong_funcdecl_entryMap,
    AGGREGATE_FLATTEN_STRUCT_TYPE_EMBEDDED_POINTER(ftdb_ulong_funcdecl_entryMap,node.__rb_parent_color,
            ptr_clear_2lsb_bits,flatten_ptr_restore_2lsb_bits);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_ulong_funcdecl_entryMap,node.rb_right);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_ulong_funcdecl_entryMap,node.rb_left);
    AGGREGATE_FLATTEN_STRUCT(ftdb_funcdecl_entry,entry);
);

FUNCTION_DEFINE_FLATTEN_STRUCT_TYPE(ftdb_ulong_global_entryMap,
    AGGREGATE_FLATTEN_STRUCT_TYPE_EMBEDDED_POINTER(ftdb_ulong_global_entryMap,node.__rb_parent_color,
            ptr_clear_2lsb_bits,flatten_ptr_restore_2lsb_bits);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_ulong_global_entryMap,node.rb_right);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_ulong_global_entryMap,node.rb_left);
    AGGREGATE_FLATTEN_STRUCT(ftdb_global_entry,entry);
);

FUNCTION_DECLARE_FLATTEN_STRUCT(func_map_entry);

FUNCTION_DEFINE_FLATTEN_STRUCT_TYPE(ftdb_ulong_static_funcs_map_entryMap,
    AGGREGATE_FLATTEN_STRUCT_TYPE_EMBEDDED_POINTER(ftdb_ulong_static_funcs_map_entryMap,node.__rb_parent_color,
            ptr_clear_2lsb_bits,flatten_ptr_restore_2lsb_bits);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_ulong_static_funcs_map_entryMap,node.rb_right);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_ulong_static_funcs_map_entryMap,node.rb_left);
    AGGREGATE_FLATTEN_STRUCT(func_map_entry,entry);
);

FUNCTION_DECLARE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_type_entryMap);
FUNCTION_DECLARE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_func_entryMap);
FUNCTION_DECLARE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_funcdecl_entryMap);
FUNCTION_DECLARE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_global_entryMap);
FUNCTION_DECLARE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_BAS_data_entryMap);


FUNCTION_DEFINE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_type_entryMap,
    AGGREGATE_FLATTEN_STRUCT_TYPE_EMBEDDED_POINTER(ftdb_stringRef_type_entryMap,node.__rb_parent_color,
            ptr_clear_2lsb_bits,flatten_ptr_restore_2lsb_bits);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_type_entryMap,node.rb_right);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_type_entryMap,node.rb_left);
    AGGREGATE_FLATTEN_STRING(key);
    AGGREGATE_FLATTEN_STRUCT(ftdb_type_entry,entry);
);

FUNCTION_DEFINE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_func_entryMap,
    AGGREGATE_FLATTEN_STRUCT_TYPE_EMBEDDED_POINTER(ftdb_stringRef_func_entryMap,node.__rb_parent_color,
            ptr_clear_2lsb_bits,flatten_ptr_restore_2lsb_bits);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_func_entryMap,node.rb_right);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_func_entryMap,node.rb_left);
    AGGREGATE_FLATTEN_STRING(key);
    AGGREGATE_FLATTEN_STRUCT(ftdb_func_entry,entry);
);

FUNCTION_DEFINE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_funcdecl_entryMap,
    AGGREGATE_FLATTEN_STRUCT_TYPE_EMBEDDED_POINTER(ftdb_stringRef_funcdecl_entryMap,node.__rb_parent_color,
            ptr_clear_2lsb_bits,flatten_ptr_restore_2lsb_bits);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_funcdecl_entryMap,node.rb_right);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_funcdecl_entryMap,node.rb_left);
    AGGREGATE_FLATTEN_STRING(key);
    AGGREGATE_FLATTEN_STRUCT(ftdb_funcdecl_entry,entry);
);

FUNCTION_DEFINE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_global_entryMap,
    AGGREGATE_FLATTEN_STRUCT_TYPE_EMBEDDED_POINTER(ftdb_stringRef_global_entryMap,node.__rb_parent_color,
            ptr_clear_2lsb_bits,flatten_ptr_restore_2lsb_bits);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_global_entryMap,node.rb_right);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_global_entryMap,node.rb_left);
    AGGREGATE_FLATTEN_STRING(key);
    AGGREGATE_FLATTEN_STRUCT(ftdb_global_entry,entry);
);

FUNCTION_DECLARE_FLATTEN_STRUCT(BAS_item);

FUNCTION_DEFINE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_BAS_data_entryMap,
    AGGREGATE_FLATTEN_STRUCT_TYPE_EMBEDDED_POINTER(ftdb_stringRef_BAS_data_entryMap,node.__rb_parent_color,
            ptr_clear_2lsb_bits,flatten_ptr_restore_2lsb_bits);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_BAS_data_entryMap,node.rb_right);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_BAS_data_entryMap,node.rb_left);
    AGGREGATE_FLATTEN_STRING(key);
    AGGREGATE_FLATTEN_STRUCT(BAS_item,entry);
);

FUNCTION_DECLARE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_func_entryListMap);
FUNCTION_DECLARE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_global_entryListMap);

FUNCTION_DEFINE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_func_entryListMap,
    AGGREGATE_FLATTEN_STRUCT_TYPE_EMBEDDED_POINTER(ftdb_stringRef_func_entryListMap,node.__rb_parent_color,
            ptr_clear_2lsb_bits,flatten_ptr_restore_2lsb_bits);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_func_entryListMap,node.rb_right);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_func_entryListMap,node.rb_left);
    AGGREGATE_FLATTEN_STRING(key);
    AGGREGATE_FLATTEN_TYPE_ARRAY(void*,entry_list,ATTR(entry_count));
    FOREACH_POINTER(void*,entry,ATTR(entry_list),ATTR(entry_count),
        FLATTEN_STRUCT(ftdb_func_entry,entry);
    );
);

FUNCTION_DEFINE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_global_entryListMap,
    AGGREGATE_FLATTEN_STRUCT_TYPE_EMBEDDED_POINTER(ftdb_stringRef_global_entryListMap,node.__rb_parent_color,
            ptr_clear_2lsb_bits,flatten_ptr_restore_2lsb_bits);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_global_entryListMap,node.rb_right);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_global_entryListMap,node.rb_left);
    AGGREGATE_FLATTEN_STRING(key);
    AGGREGATE_FLATTEN_TYPE_ARRAY(void*,entry_list,ATTR(entry_count));
    FOREACH_POINTER(void*,entry,ATTR(entry_list),ATTR(entry_count),
        FLATTEN_STRUCT(ftdb_global_entry,entry);
    );
);

FUNCTION_DEFINE_FLATTEN_STRUCT(matrix_data,
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,data,ATTR(data_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,row_ind,ATTR(row_ind_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,col_ind,ATTR(col_ind_count));
);

FUNCTION_DEFINE_FLATTEN_STRUCT(func_map_entry,
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,fids,ATTR(fids_count));
);

FUNCTION_DEFINE_FLATTEN_STRUCT(size_dep_item,
    // No recipes needed
);

FUNCTION_DECLARE_FLATTEN_STRUCT(init_data_item);

FUNCTION_DEFINE_FLATTEN_STRUCT(init_data_item,
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,id,1);
    AGGREGATE_FLATTEN_TYPE_ARRAY(const char*,name,ATTR(name_count));
    FOREACH_POINTER(const char*,s,ATTR(name),ATTR(name_count),
        FLATTEN_STRING(s);
    );
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,size,1);
    AGGREGATE_FLATTEN_STRUCT_ARRAY(size_dep_item,size_dep,1);
    AGGREGATE_FLATTEN_STRING(nullterminated);
    AGGREGATE_FLATTEN_STRING(tagged);
    AGGREGATE_FLATTEN_STRING(fuzz);
    AGGREGATE_FLATTEN_STRING(pointer);
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,min_value,1);
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,max_value,1);
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,value,1);
    AGGREGATE_FLATTEN_STRING(user_name);
    AGGREGATE_FLATTEN_STRING(protected_var);
    AGGREGATE_FLATTEN_TYPE_ARRAY(const char*,value_dep,ATTR(value_dep_count));
    FOREACH_POINTER(const char*,s,ATTR(value_dep),ATTR(value_dep_count),
        FLATTEN_STRING(s);
    );
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,fuzz_offset,1);
    AGGREGATE_FLATTEN_STRING(force_type);
    AGGREGATE_FLATTEN_TYPE_ARRAY(const char*,always_init,ATTR(always_init_count));
    FOREACH_POINTER(const char*,s,ATTR(always_init),ATTR(always_init_count),
        FLATTEN_STRING(s);
    );
    AGGREGATE_FLATTEN_STRUCT_ARRAY(init_data_item,subitems,ATTR(subitems_count));
);

FUNCTION_DEFINE_FLATTEN_STRUCT(init_data_entry,
    AGGREGATE_FLATTEN_STRING(name);
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,order,ATTR(order_count));
    AGGREGATE_FLATTEN_STRING(interface);
    AGGREGATE_FLATTEN_STRUCT_ARRAY(init_data_item,items,ATTR(items_count));
);

FUNCTION_DEFINE_FLATTEN_STRUCT(known_data_entry,
    AGGREGATE_FLATTEN_STRING(version);
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,func_ids,ATTR(func_ids_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,builtin_ids,ATTR(builtin_ids_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,asm_ids,ATTR(asm_ids_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(const char*,lib_funcs,ATTR(lib_funcs_count));
    FOREACH_POINTER(const char*,s,ATTR(lib_funcs),ATTR(lib_funcs_count),
        FLATTEN_STRING(s);
    );
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,lib_funcs_ids,ATTR(lib_funcs_ids_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,always_inc_funcs_ids,ATTR(always_inc_funcs_ids_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,replacement_ids,ATTR(replacement_ids_count));
);

FUNCTION_DEFINE_FLATTEN_STRUCT(BAS_item,
    AGGREGATE_FLATTEN_STRING(loc);
    AGGREGATE_FLATTEN_TYPE_ARRAY(const char*,entries,ATTR(entries_count));
    FOREACH_POINTER(const char*,s,ATTR(entries),ATTR(entries_count),
        FLATTEN_STRING(s);
    );
);

FUNCTION_DEFINE_FLATTEN_STRUCT(ftdb,
    AGGREGATE_FLATTEN_STRUCT_ARRAY(ftdb_func_entry,funcs,ATTR(funcs_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(ftdb_funcdecl_entry,funcdecls,ATTR(funcdecls_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(ftdb_unresolvedfunc_entry,unresolvedfuncs,ATTR(unresolvedfuncs_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(ftdb_global_entry,globals,ATTR(globals_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(ftdb_type_entry,types,ATTR(types_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(ftdb_fops_entry,fops,ATTR(fops_count));
    AGGREGATE_FLATTEN_STRUCT(stringRefMap_node,sourcemap.rb_node);
    AGGREGATE_FLATTEN_TYPE_ARRAY(const char*,sourceindex_table,ATTR(sourceindex_table_count));
    FOREACH_POINTER(const char*,s,ATTR(sourceindex_table),ATTR(sourceindex_table_count),
        FLATTEN_STRING(s);
    );
    AGGREGATE_FLATTEN_STRUCT(stringRefMap_node,modulemap.rb_node);
    AGGREGATE_FLATTEN_TYPE_ARRAY(const char*,moduleindex_table,ATTR(moduleindex_table_count));
    FOREACH_POINTER(const char*,s,ATTR(moduleindex_table),ATTR(moduleindex_table_count),
        FLATTEN_STRING(s);
    );
    AGGREGATE_FLATTEN_STRUCT(stringRefMap_node,macromap.rb_node);
    AGGREGATE_FLATTEN_STRING(version);
    AGGREGATE_FLATTEN_STRING(module);
    AGGREGATE_FLATTEN_STRING(directory);
    AGGREGATE_FLATTEN_STRING(release);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_ulong_type_entryMap,refmap.rb_node);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_type_entryMap,hrefmap.rb_node);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_ulong_func_entryMap,frefmap.rb_node);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_func_entryMap,fhrefmap.rb_node);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_func_entryListMap,fnrefmap.rb_node);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_ulong_funcdecl_entryMap,fdrefmap.rb_node);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_funcdecl_entryMap,fdhrefmap.rb_node);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_func_entryListMap,fdnrefmap.rb_node);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_ulong_global_entryMap,grefmap.rb_node);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_global_entryMap,ghrefmap.rb_node);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_global_entryListMap,gnrefmap.rb_node);

    AGGREGATE_FLATTEN_STRUCT(matrix_data,funcs_tree_calls_no_asm);
    AGGREGATE_FLATTEN_STRUCT(matrix_data,funcs_tree_calls_no_known);
    AGGREGATE_FLATTEN_STRUCT(matrix_data,funcs_tree_calls_no_known_no_asm);
    AGGREGATE_FLATTEN_STRUCT(matrix_data,funcs_tree_func_calls);
    AGGREGATE_FLATTEN_STRUCT(matrix_data,funcs_tree_func_refs);
    AGGREGATE_FLATTEN_STRUCT(matrix_data,funcs_tree_funrefs_no_asm);
    AGGREGATE_FLATTEN_STRUCT(matrix_data,funcs_tree_funrefs_no_known);
    AGGREGATE_FLATTEN_STRUCT(matrix_data,funcs_tree_funrefs_no_known_no_asm);
    AGGREGATE_FLATTEN_STRUCT(matrix_data,globs_tree_globalrefs);
    AGGREGATE_FLATTEN_STRUCT(matrix_data,types_tree_refs);
    AGGREGATE_FLATTEN_STRUCT(matrix_data,types_tree_usedrefs);
    AGGREGATE_FLATTEN_STRUCT_ARRAY(func_map_entry,static_funcs_map,ATTR(static_funcs_map_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(init_data_entry,init_data,ATTR(init_data_count));
    AGGREGATE_FLATTEN_STRUCT(known_data_entry,known_data);
    AGGREGATE_FLATTEN_STRUCT_ARRAY(BAS_item,BAS_data,ATTR(BAS_data_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(func_fptrs_item,func_fptrs_data,ATTR(func_fptrs_data_count));

    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_ulong_static_funcs_map_entryMap,static_funcs_map_index.rb_node);
    AGGREGATE_FLATTEN_STRUCT_TYPE(ftdb_stringRef_BAS_data_entryMap,BAS_data_index.rb_node);
);

FUNCTION_DEFINE_FLATTEN_STRUCT(ftdb_func_entry,
    AGGREGATE_FLATTEN_STRING(name);
    AGGREGATE_FLATTEN_STRING(__namespace);
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,fids,ATTR(fids_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,mids,ATTR(mids_count));
    AGGREGATE_FLATTEN_STRING(firstNonDeclStmt);
    AGGREGATE_FLATTEN_TYPE_ARRAY(int,isinline,1);
    AGGREGATE_FLATTEN_TYPE_ARRAY(int,istemplate,1);
    AGGREGATE_FLATTEN_STRING(classOuterFn);
    AGGREGATE_FLATTEN_TYPE_ARRAY(int,ismember,1);
    AGGREGATE_FLATTEN_STRING(__class);
    AGGREGATE_FLATTEN_TYPE_ARRAY(int,classid,1);
    AGGREGATE_FLATTEN_TYPE_ARRAY(const char*,attributes,ATTR(attributes_count));
    FOREACH_POINTER(const char*,s,ATTR(attributes),ATTR(attributes_count),
        FLATTEN_STRING(s);
    );
    AGGREGATE_FLATTEN_STRING(hash);
    AGGREGATE_FLATTEN_STRING(cshash);
    AGGREGATE_FLATTEN_STRING(template_parameters);
    AGGREGATE_FLATTEN_STRING(body);
    AGGREGATE_FLATTEN_STRING(unpreprocessed_body);
    AGGREGATE_FLATTEN_STRING(declbody);
    AGGREGATE_FLATTEN_STRING(signature);
    AGGREGATE_FLATTEN_STRING(declhash);
    AGGREGATE_FLATTEN_STRING(location);
    AGGREGATE_FLATTEN_STRING(start_loc);
    AGGREGATE_FLATTEN_STRING(end_loc);
    AGGREGATE_FLATTEN_TYPE_ARRAY(int64_t,integer_literals,ATTR(integer_literals_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(int,character_literals,ATTR(character_literals_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(double,floating_literals,ATTR(floating_literals_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(const char*,string_literals,ATTR(string_literals_count));
    FOREACH_POINTER(const char*,s,ATTR(string_literals),ATTR(string_literals_count),
        FLATTEN_STRING(s);
    );
    AGGREGATE_FLATTEN_STRUCT_ARRAY(taint_data,taint,ATTR(taint_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,calls,ATTR(calls_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(call_info,call_info,ATTR(calls_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(callref_info,callrefs,ATTR(calls_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(refcall,refcalls,ATTR(refcalls_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(call_info,refcall_info,ATTR(refcalls_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(callref_info,refcallrefs,ATTR(refcalls_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(switch_info,switches,ATTR(switches_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(csitem,csmap,ATTR(csmap_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(mexp_info,macro_expansions,ATTR(macro_expansions_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(local_info,locals,ATTR(locals_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(deref_info,derefs,ATTR(derefs_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(if_info,ifs,ATTR(ifs_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(asm_info,asms,ATTR(asms_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,globalrefs,ATTR(globalrefs_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(globalref_data,globalrefInfo,ATTR(globalrefs_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,funrefs,ATTR(funrefs_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,refs,ATTR(refs_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,decls,ATTR(decls_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,types,ATTR(types_count));
);

FUNCTION_DEFINE_FLATTEN_STRUCT(ftdb_funcdecl_entry,
    AGGREGATE_FLATTEN_STRING(name);
    AGGREGATE_FLATTEN_STRING(__namespace);
    AGGREGATE_FLATTEN_TYPE_ARRAY(int,istemplate,1);
    AGGREGATE_FLATTEN_TYPE_ARRAY(int,ismember,1);
    AGGREGATE_FLATTEN_STRING(__class);
    AGGREGATE_FLATTEN_TYPE_ARRAY(int,classid,1);
    AGGREGATE_FLATTEN_STRING(template_parameters);
    AGGREGATE_FLATTEN_STRING(decl);
    AGGREGATE_FLATTEN_STRING(signature);
    AGGREGATE_FLATTEN_STRING(declhash);
    AGGREGATE_FLATTEN_STRING(location);
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,types,ATTR(types_count));
);

FUNCTION_DEFINE_FLATTEN_STRUCT(ftdb_unresolvedfunc_entry,
    AGGREGATE_FLATTEN_STRING(name);
);

FUNCTION_DEFINE_FLATTEN_STRUCT(ftdb_global_entry,
    AGGREGATE_FLATTEN_STRING(name);
    AGGREGATE_FLATTEN_STRING(hash);
    AGGREGATE_FLATTEN_STRING(def);
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,globalrefs,ATTR(globalrefs_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,refs,ATTR(refs_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,funrefs,ATTR(funrefs_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,decls,ATTR(decls_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,mids,ATTR(mids_count));
    AGGREGATE_FLATTEN_STRING(location);
    AGGREGATE_FLATTEN_STRING(init);
    AGGREGATE_FLATTEN_TYPE_ARRAY(int64_t,integer_literals,ATTR(integer_literals_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(int,character_literals,ATTR(character_literals_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(double,floating_literals,ATTR(floating_literals_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(const char*,string_literals,ATTR(string_literals_count));
    FOREACH_POINTER(const char*,s,ATTR(string_literals),ATTR(string_literals_count),
        FLATTEN_STRING(s);
    );
);

FUNCTION_DEFINE_FLATTEN_STRUCT(bitfield,
    /* No recipes needed */
);

FUNCTION_DEFINE_FLATTEN_STRUCT(ftdb_type_entry,
    AGGREGATE_FLATTEN_STRING(hash);
    AGGREGATE_FLATTEN_STRING(class_name);
    AGGREGATE_FLATTEN_STRING(qualifiers);
    AGGREGATE_FLATTEN_STRING(str);
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,refs,ATTR(refs_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,usedrefs,ATTR(usedrefs_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,decls,ATTR(decls_count));
    AGGREGATE_FLATTEN_STRING(def);
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,memberoffsets,ATTR(memberoffsets_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,attrrefs,ATTR(attrrefs_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,attrnum,1);
    AGGREGATE_FLATTEN_STRING(name);
    AGGREGATE_FLATTEN_TYPE_ARRAY(int,isdependent,1);
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,globalrefs,ATTR(globalrefs_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(int64_t,enumvalues,ATTR(enumvalues_count));
    AGGREGATE_FLATTEN_STRING(outerfn);
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,outerfnid,1);
    AGGREGATE_FLATTEN_TYPE_ARRAY(int,isimplicit,1);
    AGGREGATE_FLATTEN_TYPE_ARRAY(int,isunion,1);
    AGGREGATE_FLATTEN_TYPE_ARRAY(const char*,refnames,ATTR(refnames_count));
    FOREACH_POINTER(const char*,s,ATTR(refnames),ATTR(refnames_count),
        FLATTEN_STRING(s);
    );
    AGGREGATE_FLATTEN_STRING(location);
    AGGREGATE_FLATTEN_TYPE_ARRAY(int,isvariadic,1);
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,funrefs,ATTR(funrefs_count));
    AGGREGATE_FLATTEN_TYPE_ARRAY(const char*,useddef,ATTR(useddef_count));
    FOREACH_POINTER(const char*,s,ATTR(useddef),ATTR(useddef_count),
        FLATTEN_STRING(s);
    );
    AGGREGATE_FLATTEN_STRING(defhead);
    AGGREGATE_FLATTEN_TYPE_ARRAY(const char*,identifiers,ATTR(identifiers_count));
    FOREACH_POINTER(const char*,s,ATTR(identifiers),ATTR(identifiers_count),
        FLATTEN_STRING(s);
    );
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,methods,ATTR(methods_count));
    AGGREGATE_FLATTEN_STRUCT_ARRAY(bitfield,bitfields,ATTR(bitfields_count));
);

FUNCTION_DEFINE_FLATTEN_STRUCT(ftdb_fops_member_entry,
    AGGREGATE_FLATTEN_TYPE_ARRAY(unsigned long,func_ids,ATTR(func_ids_count));
);

FUNCTION_DEFINE_FLATTEN_STRUCT(ftdb_fops_entry,
    AGGREGATE_FLATTEN_STRING(location);
    AGGREGATE_FLATTEN_STRUCT_ARRAY(ftdb_fops_member_entry,members,ATTR(members_count));
);

FUNCTION_DEFINE_FLATTEN_STRUCT(func_fptrs_entry,
    AGGREGATE_FLATTEN_STRING(fname);
    AGGREGATE_FLATTEN_TYPE_ARRAY(long*,ids,ATTR(ids_count));
);

FUNCTION_DEFINE_FLATTEN_STRUCT(func_fptrs_item,
    AGGREGATE_FLATTEN_STRUCT_ARRAY(func_fptrs_entry,entries,ATTR(entries_count));
);

/* TODO: memory leaks */
static void libftdb_create_ftdb_func_entry(PyObject *self, PyObject* func_entry, struct ftdb_func_entry* new_entry) {

    new_entry->name = FTDB_ENTRY_STRING(func_entry,name);
    new_entry->__namespace = FTDB_ENTRY_STRING_OPTIONAL(func_entry,namespace);
    new_entry->id = FTDB_ENTRY_ULONG(func_entry,id);
    new_entry->fid = FTDB_ENTRY_ULONG(func_entry,fid);
    new_entry->fids_count = FTDB_ENTRY_ARRAY_SIZE(func_entry,fids);
    new_entry->fids = FTDB_ENTRY_ULONG_ARRAY(func_entry,fids);
    new_entry->mids_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(func_entry,mids);
    new_entry->mids = FTDB_ENTRY_ULONG_ARRAY_OPTIONAL(func_entry,mids);
    new_entry->nargs = FTDB_ENTRY_ULONG(func_entry,nargs);
    new_entry->isvariadic = FTDB_ENTRY_BOOL(func_entry,variadic);
    new_entry->firstNonDeclStmt = FTDB_ENTRY_STRING(func_entry,firstNonDeclStmt);
    new_entry->isinline = FTDB_ENTRY_BOOL_OPTIONAL(func_entry,inline);
    new_entry->istemplate = FTDB_ENTRY_BOOL_OPTIONAL(func_entry,template);
    new_entry->classOuterFn = FTDB_ENTRY_STRING_OPTIONAL(func_entry,classOuterFn);
    new_entry->linkage = FTDB_ENTRY_ENUM_FROM_STRING(func_entry,linkage,functionLinkage);
    new_entry->ismember = FTDB_ENTRY_BOOL_OPTIONAL(func_entry,member);
    new_entry->__class = FTDB_ENTRY_STRING_OPTIONAL(func_entry,class);
    new_entry->classid = FTDB_ENTRY_ULONG_OPTIONAL(func_entry,classid);
    new_entry->attributes_count = FTDB_ENTRY_ARRAY_SIZE(func_entry,attributes);
    new_entry->attributes = FTDB_ENTRY_STRING_ARRAY(func_entry,attributes);
    new_entry->hash = FTDB_ENTRY_STRING(func_entry,hash);
    new_entry->cshash = FTDB_ENTRY_STRING(func_entry,cshash);
    new_entry->template_parameters = FTDB_ENTRY_STRING_OPTIONAL(func_entry,template_parameters);
    new_entry->body = FTDB_ENTRY_STRING(func_entry,body);
    new_entry->unpreprocessed_body = FTDB_ENTRY_STRING(func_entry,unpreprocessed_body);
    new_entry->declbody = FTDB_ENTRY_STRING(func_entry,declbody);
    new_entry->signature = FTDB_ENTRY_STRING(func_entry,signature);
    new_entry->declhash = FTDB_ENTRY_STRING(func_entry,declhash);
    new_entry->location = FTDB_ENTRY_STRING(func_entry,location);
    new_entry->start_loc = FTDB_ENTRY_STRING(func_entry,start_loc);
    new_entry->end_loc = FTDB_ENTRY_STRING(func_entry,end_loc);
    new_entry->refcount = FTDB_ENTRY_ULONG(func_entry,refcount);

    PyObject* key_literals = PyUnicode_FromString("literals");
    PyObject* literals = PyDict_GetItem(func_entry,key_literals);
    Py_DecRef(key_literals);
    new_entry->integer_literals = FTDB_ENTRY_INT64_ARRAY(literals,integer);
    new_entry->integer_literals_count = FTDB_ENTRY_ARRAY_SIZE(literals,integer);
    new_entry->character_literals = FTDB_ENTRY_UINT_ARRAY(literals,character);
    new_entry->character_literals_count = FTDB_ENTRY_ARRAY_SIZE(literals,character);
    new_entry->floating_literals = FTDB_ENTRY_FLOAT_ARRAY(literals,floating);
    new_entry->floating_literals_count = FTDB_ENTRY_ARRAY_SIZE(literals,floating);
    new_entry->string_literals = FTDB_ENTRY_STRING_ARRAY(literals,string);
    new_entry->string_literals_count = FTDB_ENTRY_ARRAY_SIZE(literals,string);
    new_entry->declcount = FTDB_ENTRY_ULONG(func_entry,declcount);

    PyObject* key_taint = PyUnicode_FromString("taint");
    PyObject* taint = PyDict_GetItem(func_entry,key_taint);
    Py_DecRef(key_taint);
    PyObject* taint_keys = PyDict_Keys(taint);
    new_entry->taint_count = PyDict_Size(taint);
    new_entry->taint = calloc(new_entry->taint_count,sizeof(struct taint_data));
    for (Py_ssize_t i=0; i<PyList_Size(taint_keys); ++i) {
        PyObject* py_int_key = PyLong_FromString((char*)PyString_get_c_str(PyList_GetItem(taint_keys,i)),0,10);
        if (py_int_key) {
            PyObject* taint_tuple_list = PyDict_GetItem(taint, PyList_GetItem(taint_keys,i));
            unsigned long integer_key = PyLong_AsUnsignedLong(py_int_key);
            struct taint_data* taint_data = &new_entry->taint[integer_key];
            taint_data->taint_list_count = PyList_Size(taint_tuple_list);
            taint_data->taint_list = calloc(taint_data->taint_list_count,sizeof(struct taint_element));
            for (Py_ssize_t j=0; j<PyList_Size(taint_tuple_list); ++j) {
                PyObject* taint_tuple_as_list = PyList_GetItem(taint_tuple_list,j);
                taint_data->taint_list[j].taint_level = PyLong_AsUnsignedLong(PyList_GetItem(taint_tuple_as_list,0));
                taint_data->taint_list[j].varid = PyLong_AsUnsignedLong(PyList_GetItem(taint_tuple_as_list,1));
            }
        }
    }
    Py_DecRef(taint_keys);

    new_entry->calls = FTDB_ENTRY_ULONG_ARRAY(func_entry,calls);
    new_entry->calls_count = FTDB_ENTRY_ARRAY_SIZE(func_entry,calls);

    PyObject* key_call_info = PyUnicode_FromString("call_info");
    PyObject* call_info = PyDict_GetItem(func_entry,key_call_info);
    Py_DecRef(key_call_info);
    new_entry->call_info = calloc(new_entry->calls_count,sizeof(struct call_info));
    for (Py_ssize_t i=0; i<PyList_Size(call_info); ++i) {
        PyObject* py_single_call_info = PyList_GetItem(call_info,i);
        struct call_info* single_call_info = &new_entry->call_info[i];
        single_call_info->start = FTDB_ENTRY_STRING(py_single_call_info,start);
        single_call_info->end = FTDB_ENTRY_STRING(py_single_call_info,end);
        single_call_info->ord = FTDB_ENTRY_ULONG(py_single_call_info,ord);
        single_call_info->expr = FTDB_ENTRY_STRING(py_single_call_info,expr);
        single_call_info->loc = FTDB_ENTRY_STRING(py_single_call_info,loc);
        single_call_info->csid = FTDB_ENTRY_INT64_OPTIONAL(py_single_call_info,csid);
        single_call_info->args = FTDB_ENTRY_ULONG_ARRAY(py_single_call_info,args);
        single_call_info->args_count = FTDB_ENTRY_ARRAY_SIZE(py_single_call_info,args);
    }

    PyObject* key_callrefs = PyUnicode_FromString("callrefs");
    PyObject* callrefs = PyDict_GetItem(func_entry,key_callrefs);
    Py_DecRef(key_callrefs);
    new_entry->callrefs = calloc(new_entry->calls_count,sizeof(struct callref_info));
    for (Py_ssize_t i=0; i<PyList_Size(callrefs); ++i) {
        PyObject* py_single_callref = PyList_GetItem(callrefs,i);
        struct callref_info* single_callref = &new_entry->callrefs[i];
        single_callref->callarg_count = PyList_Size(py_single_callref);
        single_callref->callarg = calloc(single_callref->callarg_count,sizeof(struct callref_data));
        for (unsigned long j=0; j<single_callref->callarg_count; ++j) {
            PyObject* py_callref_data = PyList_GetItem(py_single_callref,j);
            single_callref->callarg[j].type = FTDB_ENTRY_ENUM_FROM_STRING(py_callref_data,type,exprType);
            single_callref->callarg[j].pos = FTDB_ENTRY_ULONG(py_callref_data,pos);
            if (single_callref->callarg[j].type==EXPR_STRINGLITERAL) {
                single_callref->callarg[j].string_literal = FTDB_ENTRY_STRING_OPTIONAL(py_callref_data,id);
            }
            else if (single_callref->callarg[j].type==EXPR_FLOATLITERAL) {
                single_callref->callarg[j].floating_literal = FTDB_ENTRY_FLOAT_OPTIONAL(py_callref_data,id);
            }
            else if (single_callref->callarg[j].type==EXPR_INTEGERLITERAL) {
                single_callref->callarg[j].integer_literal = FTDB_ENTRY_INT64_OPTIONAL(py_callref_data,id);
            }
            else if (single_callref->callarg[j].type==EXPR_CHARLITERAL) {
                single_callref->callarg[j].character_literal = FTDB_ENTRY_INT_OPTIONAL(py_callref_data,id);
            }
            else {
                single_callref->callarg[j].id = FTDB_ENTRY_ULONG_OPTIONAL(py_callref_data,id);
            }
        }
    }


    PyObject* key_refcalls = PyUnicode_FromString("refcalls");
    PyObject* refcalls = PyDict_GetItem(func_entry,key_refcalls);
    Py_DecRef(key_refcalls);
    new_entry->refcalls_count = PyList_Size(refcalls);
    new_entry->refcalls = calloc(new_entry->refcalls_count,sizeof(struct refcall));
    for (Py_ssize_t i=0; i<new_entry->refcalls_count; ++i) {
        PyObject* py_refcall_tuple = PyList_GetItem(refcalls,i);
        new_entry->refcalls[i].fid = PyLong_AsLong(PyList_GetItem(py_refcall_tuple,0));
        if (PyList_Size(py_refcall_tuple)>1) {
            new_entry->refcalls[i].ismembercall = 1;
            new_entry->refcalls[i].cid = PyLong_AsLong(PyList_GetItem(py_refcall_tuple,1));
            new_entry->refcalls[i].field_index = PyLong_AsLong(PyList_GetItem(py_refcall_tuple,2));
        }
    }

    PyObject* key_refcall_info = PyUnicode_FromString("refcall_info");
    PyObject* refcall_info = PyDict_GetItem(func_entry,key_refcall_info);
    Py_DecRef(key_refcall_info);
    new_entry->refcall_info = calloc(new_entry->refcalls_count,sizeof(struct call_info));
    for (Py_ssize_t i=0; i<PyList_Size(refcall_info); ++i) {
        PyObject* py_single_refcall_info = PyList_GetItem(refcall_info,i);
        struct call_info* single_refcall_info = &new_entry->refcall_info[i];
        single_refcall_info->start = FTDB_ENTRY_STRING(py_single_refcall_info,start);
        single_refcall_info->end = FTDB_ENTRY_STRING(py_single_refcall_info,end);
        single_refcall_info->ord = FTDB_ENTRY_ULONG(py_single_refcall_info,ord);
        single_refcall_info->expr = FTDB_ENTRY_STRING(py_single_refcall_info,expr);
        single_refcall_info->loc = FTDB_ENTRY_STRING_OPTIONAL(py_single_refcall_info,loc);
        single_refcall_info->csid = FTDB_ENTRY_INT64_OPTIONAL(py_single_refcall_info,csid);
        single_refcall_info->args = FTDB_ENTRY_ULONG_ARRAY(py_single_refcall_info,args);
        single_refcall_info->args_count = FTDB_ENTRY_ARRAY_SIZE(py_single_refcall_info,args);
    }
    PyObject* key_refcallrefs = PyUnicode_FromString("refcallrefs");
    PyObject* refcallrefs = PyDict_GetItem(func_entry,key_refcallrefs);
    Py_DecRef(key_refcallrefs);
    new_entry->refcallrefs = calloc(new_entry->refcalls_count,sizeof(struct callref_info));
    for (Py_ssize_t i=0; i<PyList_Size(refcallrefs); ++i) {
        PyObject* py_single_refcallref = PyList_GetItem(refcallrefs,i);
        struct callref_info* single_refcallref = &new_entry->refcallrefs[i];
        single_refcallref->callarg_count = PyList_Size(py_single_refcallref);
        single_refcallref->callarg = calloc(single_refcallref->callarg_count,sizeof(struct callref_data));
        for (unsigned long j=0; j<single_refcallref->callarg_count; ++j) {
            PyObject* py_refcallref_data = PyList_GetItem(py_single_refcallref,j);
            single_refcallref->callarg[j].type = FTDB_ENTRY_ENUM_FROM_STRING(py_refcallref_data,type,exprType);
            single_refcallref->callarg[j].pos = FTDB_ENTRY_ULONG(py_refcallref_data,pos);
            if (single_refcallref->callarg[j].type==EXPR_STRINGLITERAL) {
                single_refcallref->callarg[j].string_literal = FTDB_ENTRY_STRING_OPTIONAL(py_refcallref_data,id);
            }
            else if (single_refcallref->callarg[j].type==EXPR_FLOATLITERAL) {
                single_refcallref->callarg[j].floating_literal = FTDB_ENTRY_FLOAT_OPTIONAL(py_refcallref_data,id);
            }
            else if (single_refcallref->callarg[j].type==EXPR_INTEGERLITERAL) {
                single_refcallref->callarg[j].integer_literal = FTDB_ENTRY_INT64_OPTIONAL(py_refcallref_data,id);
            }
            else if (single_refcallref->callarg[j].type==EXPR_CHARLITERAL) {
                single_refcallref->callarg[j].character_literal = FTDB_ENTRY_INT_OPTIONAL(py_refcallref_data,id);
            }
            else {
                single_refcallref->callarg[j].id = FTDB_ENTRY_ULONG_OPTIONAL(py_refcallref_data,id);
            }
        }
    }

    PyObject* key_switches = PyUnicode_FromString("switches");
    PyObject* switches = PyDict_GetItem(func_entry,key_switches);
    Py_DecRef(key_switches);
    new_entry->switches_count = PyList_Size(switches);
    new_entry->switches = calloc(new_entry->switches_count,sizeof(struct switch_info));
    for (Py_ssize_t i=0; i<PyList_Size(switches); ++i) {
        PyObject* py_switch_info = PyList_GetItem(switches,i);
        struct switch_info* switch_info = &new_entry->switches[i];
        switch_info->condition = FTDB_ENTRY_STRING(py_switch_info,condition);
        switch_info->cases_count = FTDB_ENTRY_ARRAY_SIZE(py_switch_info,cases);
        switch_info->cases = calloc(switch_info->cases_count,sizeof(struct case_info));
        PyObject* key_cases = PyUnicode_FromString("cases");
        PyObject* cases = PyDict_GetItem(py_switch_info,key_cases);
        Py_DecRef(key_cases);
        for (Py_ssize_t j=0; j<PyList_Size(cases); ++j) {
            PyObject* py_case_info = PyList_GetItem(cases,j);
            struct case_info* case_info = &switch_info->cases[j];
            case_info->lhs.expr_value = PyLong_AsLong(PyList_GetItem(py_case_info,0));
            case_info->lhs.enum_code = PyString_get_c_str(PyList_GetItem(py_case_info,1));
            case_info->lhs.macro_code = PyString_get_c_str(PyList_GetItem(py_case_info,2));
            case_info->lhs.raw_code = PyString_get_c_str(PyList_GetItem(py_case_info,3));
            if (PyList_Size(py_case_info)>4) {
                case_info->rhs = calloc(1,sizeof(struct case_data));
                case_info->rhs->expr_value = PyLong_AsLong(PyList_GetItem(py_case_info,4));
                case_info->rhs->enum_code = PyString_get_c_str(PyList_GetItem(py_case_info,5));
                case_info->rhs->macro_code = PyString_get_c_str(PyList_GetItem(py_case_info,6));
                case_info->rhs->raw_code = PyString_get_c_str(PyList_GetItem(py_case_info,7));
            }
        }
    }

    PyObject* key_csmap = PyUnicode_FromString("csmap");
    PyObject* csmap = PyDict_GetItem(func_entry,key_csmap);
    Py_DecRef(key_csmap);
    new_entry->csmap_count = PyList_Size(csmap);
    new_entry->csmap = calloc(new_entry->csmap_count,sizeof(struct csitem));
    for (Py_ssize_t i=0; i<PyList_Size(csmap); ++i) {
        PyObject* py_csitem = PyList_GetItem(csmap,i);
        struct csitem* csitem = &new_entry->csmap[i];
        csitem->pid = FTDB_ENTRY_INT64(py_csitem,pid);
        csitem->id = FTDB_ENTRY_ULONG(py_csitem,id);
        csitem->cf = FTDB_ENTRY_STRING(py_csitem,cf);
    }

    PyObject* key_macro_expansions = PyUnicode_FromString("macro_expansions");
    if (PyDict_Contains(func_entry,key_macro_expansions)){
        PyObject* macro_expansions = PyDict_GetItem(func_entry,key_macro_expansions);
        new_entry->macro_expansions_count = PyList_Size(macro_expansions);
        new_entry->macro_expansions = calloc(new_entry->macro_expansions_count,sizeof(struct mexp_info));
        for (Py_ssize_t i=0; i<PyList_Size(macro_expansions); ++i) {
            PyObject* py_mexp_info = PyList_GetItem(macro_expansions,i);
            struct mexp_info* mexp_info = &new_entry->macro_expansions[i];
            mexp_info->pos = FTDB_ENTRY_ULONG(py_mexp_info,pos);
            mexp_info->len = FTDB_ENTRY_ULONG(py_mexp_info,len);
            mexp_info->text = FTDB_ENTRY_STRING(py_mexp_info,text);
        }
    }
    Py_DecRef(key_macro_expansions);

    PyObject* key_locals = PyUnicode_FromString("locals");
    PyObject* locals = PyDict_GetItem(func_entry,key_locals);
    Py_DecRef(key_locals);
    new_entry->locals_count = PyList_Size(locals);
    new_entry->locals = calloc(new_entry->locals_count,sizeof(struct local_info));
    for (Py_ssize_t i=0; i<PyList_Size(locals); ++i) {
        PyObject* py_local_info = PyList_GetItem(locals,i);
        struct local_info* local_info = &new_entry->locals[i];
        local_info->id = FTDB_ENTRY_ULONG(py_local_info,id);
        local_info->name = FTDB_ENTRY_STRING(py_local_info,name);
        local_info->isparm = FTDB_ENTRY_BOOL(py_local_info,parm);
        local_info->type = FTDB_ENTRY_ULONG(py_local_info,type);
        local_info->isstatic = FTDB_ENTRY_BOOL(py_local_info,static);
        local_info->isused = FTDB_ENTRY_BOOL(py_local_info,used);
        local_info->location = FTDB_ENTRY_STRING(py_local_info,location);
        local_info->csid = FTDB_ENTRY_INT64_OPTIONAL(py_local_info,csid);
    }

    PyObject* key_derefs = PyUnicode_FromString("derefs");
    PyObject* derefs = PyDict_GetItem(func_entry,key_derefs);
    Py_DecRef(key_derefs);
    new_entry->derefs_count = PyList_Size(derefs);
    new_entry->derefs = calloc(new_entry->derefs_count,sizeof(struct deref_info));
    for (Py_ssize_t i=0; i<PyList_Size(derefs); ++i) {
        PyObject* py_deref_info = PyList_GetItem(derefs,i);
        struct deref_info* deref_info = &new_entry->derefs[i];
        deref_info->kind = FTDB_ENTRY_ENUM_FROM_STRING(py_deref_info,kind,exprType);
        deref_info->offset = FTDB_ENTRY_INT64_OPTIONAL(py_deref_info,offset);
        deref_info->basecnt = FTDB_ENTRY_ULONG_OPTIONAL(py_deref_info,basecnt);
        deref_info->expr = FTDB_ENTRY_STRING(py_deref_info,expr);
        deref_info->csid = FTDB_ENTRY_INT64(py_deref_info,csid);
        deref_info->ord_count = FTDB_ENTRY_ARRAY_SIZE(py_deref_info,ord);
        deref_info->ord = FTDB_ENTRY_ULONG_ARRAY(py_deref_info,ord);
        if ((deref_info->kind==EXPR_MEMBER)||(deref_info->kind==EXPR_OFFSETOF)) {
            deref_info->member_count = FTDB_ENTRY_ARRAY_SIZE(py_deref_info,member);
            deref_info->member = FTDB_ENTRY_INT64_ARRAY(py_deref_info,member);
            deref_info->type_count = FTDB_ENTRY_ARRAY_SIZE(py_deref_info,type);
            deref_info->type = FTDB_ENTRY_ULONG_ARRAY(py_deref_info,type);
        }
        if (deref_info->kind==EXPR_MEMBER) {
            deref_info->access_count = FTDB_ENTRY_ARRAY_SIZE(py_deref_info,access);
            deref_info->access = FTDB_ENTRY_ULONG_ARRAY(py_deref_info,access);
            deref_info->shift_count = FTDB_ENTRY_ARRAY_SIZE(py_deref_info,shift);
            deref_info->shift = FTDB_ENTRY_INT64_ARRAY(py_deref_info,shift);
            PyObject* key_mcall = PyUnicode_FromString("mcall");
            if (PyDict_Contains(py_deref_info,key_mcall)) {
                PyObject* mcall = PyDict_GetItem(py_deref_info,key_mcall);
                deref_info->mcall_count = PyList_Size(mcall);
                deref_info->mcall = calloc(deref_info->mcall_count,sizeof(int64_t));
                for (unsigned long j=0; j<deref_info->mcall_count; ++j) {
                    deref_info->mcall[j] = PyLong_AsLong(PyList_GetItem(mcall,j));
                }
            }
            Py_DecRef(key_mcall);
        }
        PyObject* key_offsetrefs = PyUnicode_FromString("offsetrefs");
        PyObject* offsetrefs = PyDict_GetItem(py_deref_info,key_offsetrefs);
        Py_DecRef(key_offsetrefs);
        deref_info->offsetrefs_count = PyList_Size(offsetrefs);
        deref_info->offsetrefs = calloc(deref_info->offsetrefs_count,sizeof(struct offsetref_info));
        for (unsigned long j=0; j<deref_info->offsetrefs_count; ++j) {
            PyObject* py_offsetref_info = PyList_GetItem(offsetrefs,j);
            struct offsetref_info* offsetref_info = &deref_info->offsetrefs[j];
            offsetref_info->kind = FTDB_ENTRY_ENUM_FROM_STRING(py_offsetref_info,kind,exprType);
            if (offsetref_info->kind==EXPR_STRING) {
                offsetref_info->id_string = FTDB_ENTRY_STRING(py_offsetref_info,id);
            }
            else if (offsetref_info->kind==EXPR_FLOATING) {
                offsetref_info->id_float = FTDB_ENTRY_FLOAT(py_offsetref_info,id);
            }
            else {
                offsetref_info->id_integer = FTDB_ENTRY_INT64(py_offsetref_info,id);
            }
            offsetref_info->mi = FTDB_ENTRY_ULONG_OPTIONAL(py_offsetref_info,mi);
            offsetref_info->di = FTDB_ENTRY_ULONG_OPTIONAL(py_offsetref_info,di);
            offsetref_info->cast = FTDB_ENTRY_ULONG_OPTIONAL(py_offsetref_info,cast);
        }
    }
    PyObject* key_ifs = PyUnicode_FromString("ifs");
    PyObject* ifs = PyDict_GetItem(func_entry,key_ifs);
    Py_DecRef(key_ifs);
    new_entry->ifs_count = PyList_Size(ifs);
    new_entry->ifs = calloc(new_entry->ifs_count,sizeof(struct if_info));
    for (Py_ssize_t i=0; i<PyList_Size(ifs); ++i) {
        PyObject* py_if_info = PyList_GetItem(ifs,i);
        struct if_info* if_info = &new_entry->ifs[i];
        if_info->csid = FTDB_ENTRY_INT64(py_if_info,csid);
        PyObject* key_refs = PyUnicode_FromString("refs");
        PyObject* if_refs = PyDict_GetItem(py_if_info,key_refs);
        Py_DecRef(key_refs);
        if_info->refs_count = PyList_Size(if_refs);
        if_info->refs = calloc(if_info->refs_count,sizeof(struct ifref_info));
        for (unsigned long j=0; j<if_info->refs_count; ++j) {
            PyObject* py_ifref_info = PyList_GetItem(if_refs,j);
            struct ifref_info* ifref_info = &if_info->refs[j];
            ifref_info->type = FTDB_ENTRY_ENUM_FROM_STRING(py_ifref_info,type,exprType);
            if (ifref_info->type==EXPR_STRINGLITERAL) {
                ifref_info->string_literal = FTDB_ENTRY_STRING_OPTIONAL(py_ifref_info,id);
            }
            else if (ifref_info->type==EXPR_FLOATLITERAL) {
                ifref_info->floating_literal = FTDB_ENTRY_FLOAT_OPTIONAL(py_ifref_info,id);
            }
            else if (ifref_info->type==EXPR_INTEGERLITERAL) {
                ifref_info->integer_literal = FTDB_ENTRY_INT64_OPTIONAL(py_ifref_info,id);
            }
            else if (ifref_info->type==EXPR_CHARLITERAL) {
                ifref_info->character_literal = FTDB_ENTRY_INT_OPTIONAL(py_ifref_info,id);
            }
            else {
                ifref_info->id = FTDB_ENTRY_ULONG_OPTIONAL(py_ifref_info,id);
            }

        }
    }

    PyObject* key_asm = PyUnicode_FromString("asm");
    PyObject* asms = PyDict_GetItem(func_entry,key_asm);
    Py_DecRef(key_asm);
    new_entry->asms_count = PyList_Size(asms);
    new_entry->asms = calloc(new_entry->asms_count,sizeof(struct asm_info));
    for (Py_ssize_t i=0; i<PyList_Size(asms); ++i) {
        PyObject* py_asm_info = PyList_GetItem(asms,i);
        struct asm_info* asm_info = &new_entry->asms[i];
        asm_info->csid = FTDB_ENTRY_INT64(py_asm_info,csid);
        asm_info->str = FTDB_ENTRY_STRING(py_asm_info,str);
    }

    new_entry->globalrefs_count = FTDB_ENTRY_ARRAY_SIZE(func_entry,globalrefs);
    new_entry->globalrefs = FTDB_ENTRY_ULONG_ARRAY(func_entry,globalrefs);

    PyObject* key_globalrefInfo = PyUnicode_FromString("globalrefInfo");
    PyObject* globalrefInfo = PyDict_GetItem(func_entry,key_globalrefInfo);
    Py_DecRef(key_globalrefInfo);
    new_entry->globalrefInfo = calloc(new_entry->globalrefs_count,sizeof(struct globalref_data));
    for (Py_ssize_t i=0; i<PyList_Size(globalrefInfo); ++i) {
        PyObject* py_globalref_data = PyList_GetItem(globalrefInfo,i);
        struct globalref_data* globalref_data = &new_entry->globalrefInfo[i];
        globalref_data->refs_count = PyList_Size(py_globalref_data);
        globalref_data->refs = calloc(globalref_data->refs_count,sizeof(struct globalref_info));
        for (Py_ssize_t j=0; j<PyList_Size(py_globalref_data); ++j) {
            PyObject* py_globalref_info = PyList_GetItem(py_globalref_data,j);
            struct globalref_info* globalref_info = &globalref_data->refs[j];
            globalref_info->start = FTDB_ENTRY_STRING(py_globalref_info,start);
            globalref_info->end = FTDB_ENTRY_STRING(py_globalref_info,end);
        }
    }

    new_entry->funrefs_count = FTDB_ENTRY_ARRAY_SIZE(func_entry,funrefs);
    new_entry->funrefs = FTDB_ENTRY_ULONG_ARRAY(func_entry,funrefs);
    new_entry->refs_count = FTDB_ENTRY_ARRAY_SIZE(func_entry,refs);
    new_entry->refs = FTDB_ENTRY_ULONG_ARRAY(func_entry,refs);
    new_entry->decls_count = FTDB_ENTRY_ARRAY_SIZE(func_entry,decls);
    new_entry->decls = FTDB_ENTRY_ULONG_ARRAY(func_entry,decls);
    new_entry->types_count = FTDB_ENTRY_ARRAY_SIZE(func_entry,types);
    new_entry->types = FTDB_ENTRY_ULONG_ARRAY(func_entry,types);
}

static void libftdb_create_ftdb_funcdecl_entry(PyObject *self, PyObject* funcdecl_entry,struct ftdb_funcdecl_entry* new_entry) {

    new_entry->name = FTDB_ENTRY_STRING(funcdecl_entry,name);
    new_entry->__namespace = FTDB_ENTRY_STRING_OPTIONAL(funcdecl_entry,namespace);
    new_entry->id = FTDB_ENTRY_ULONG(funcdecl_entry,id);
    new_entry->fid = FTDB_ENTRY_ULONG(funcdecl_entry,fid);
    new_entry->nargs = FTDB_ENTRY_ULONG(funcdecl_entry,nargs);
    new_entry->isvariadic = FTDB_ENTRY_BOOL(funcdecl_entry,variadic);
    new_entry->istemplate = FTDB_ENTRY_BOOL_OPTIONAL(funcdecl_entry,template);
    new_entry->linkage = FTDB_ENTRY_ENUM_FROM_STRING(funcdecl_entry,linkage,functionLinkage);
    new_entry->ismember = FTDB_ENTRY_BOOL_OPTIONAL(funcdecl_entry,member);
    new_entry->__class = FTDB_ENTRY_STRING_OPTIONAL(funcdecl_entry,class);
    new_entry->classid = FTDB_ENTRY_ULONG_OPTIONAL(funcdecl_entry,classid);
    new_entry->template_parameters = FTDB_ENTRY_STRING_OPTIONAL(funcdecl_entry,template_parameters);
    new_entry->decl = FTDB_ENTRY_STRING(funcdecl_entry,decl);
    new_entry->signature = FTDB_ENTRY_STRING(funcdecl_entry,signature);
    new_entry->declhash = FTDB_ENTRY_STRING(funcdecl_entry,declhash);
    new_entry->location = FTDB_ENTRY_STRING(funcdecl_entry,location);
    new_entry->refcount = FTDB_ENTRY_ULONG(funcdecl_entry,refcount);
    new_entry->types_count = FTDB_ENTRY_ARRAY_SIZE(funcdecl_entry,types);
    new_entry->types = FTDB_ENTRY_ULONG_ARRAY(funcdecl_entry,types);
}

static void libftdb_create_ftdb_global_entry(PyObject *self, PyObject* global_entry, struct ftdb_global_entry* new_entry) {

    new_entry->name = FTDB_ENTRY_STRING(global_entry,name);
    new_entry->hash = FTDB_ENTRY_STRING(global_entry,hash);
    new_entry->id = FTDB_ENTRY_ULONG(global_entry,id);
    new_entry->def = FTDB_ENTRY_STRING(global_entry,def);
    new_entry->globalrefs_count = FTDB_ENTRY_ARRAY_SIZE(global_entry,globalrefs);
    new_entry->globalrefs = FTDB_ENTRY_ULONG_ARRAY(global_entry,globalrefs);
    new_entry->refs_count = FTDB_ENTRY_ARRAY_SIZE(global_entry,refs);
    new_entry->refs = FTDB_ENTRY_ULONG_ARRAY(global_entry,refs);
    new_entry->funrefs_count = FTDB_ENTRY_ARRAY_SIZE(global_entry,funrefs);
    new_entry->funrefs = FTDB_ENTRY_ULONG_ARRAY(global_entry,funrefs);
    new_entry->decls_count = FTDB_ENTRY_ARRAY_SIZE(global_entry,decls);
    new_entry->decls = FTDB_ENTRY_ULONG_ARRAY(global_entry,decls);
    new_entry->fid = FTDB_ENTRY_ULONG(global_entry,fid);
    new_entry->mids_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(global_entry,mids);
    new_entry->mids = FTDB_ENTRY_ULONG_ARRAY_OPTIONAL(global_entry,mids);
    new_entry->type = FTDB_ENTRY_ULONG(global_entry,type);
    new_entry->linkage = FTDB_ENTRY_ENUM_FROM_STRING(global_entry,linkage,functionLinkage);
    new_entry->location = FTDB_ENTRY_STRING(global_entry,location);
    new_entry->deftype = FTDB_ENTRY_ENUM_FROM_ULONG(global_entry,deftype,globalDefType);
    new_entry->hasinit = FTDB_ENTRY_INT(global_entry,hasinit);
    new_entry->init = FTDB_ENTRY_STRING(global_entry,init);

    PyObject* key_literals = PyUnicode_FromString("literals");
    PyObject* literals = PyDict_GetItem(global_entry,key_literals);
    Py_DecRef(key_literals);
    new_entry->integer_literals = FTDB_ENTRY_INT64_ARRAY(literals,integer);
    new_entry->integer_literals_count = FTDB_ENTRY_ARRAY_SIZE(literals,integer);
    new_entry->character_literals = FTDB_ENTRY_UINT_ARRAY(literals,character);
    new_entry->character_literals_count = FTDB_ENTRY_ARRAY_SIZE(literals,character);
    new_entry->floating_literals = FTDB_ENTRY_FLOAT_ARRAY(literals,floating);
    new_entry->floating_literals_count = FTDB_ENTRY_ARRAY_SIZE(literals,floating);
    new_entry->string_literals = FTDB_ENTRY_STRING_ARRAY(literals,string);
    new_entry->string_literals_count = FTDB_ENTRY_ARRAY_SIZE(literals,string);
}

static int bitfield_compare (const void * a, const void * b)
{
  if ( ((struct bitfield*)a)->index <  ((struct bitfield*)b)->index ) return -1;
  if ( ((struct bitfield*)a)->index >  ((struct bitfield*)b)->index ) return 1;

  return 0;
}

static void libftdb_create_ftdb_type_entry(PyObject *self, PyObject* type_entry, struct ftdb_type_entry* new_entry) {

    new_entry->id = FTDB_ENTRY_ULONG(type_entry,id);
    new_entry->fid = FTDB_ENTRY_ULONG(type_entry,fid);
    new_entry->hash = FTDB_ENTRY_STRING(type_entry,hash);
    new_entry->class_name = FTDB_ENTRY_STRING(type_entry,class);
    new_entry->__class = FTDB_ENTRY_ENUM_FROM_STRING(type_entry,class,TypeClass);
    new_entry->qualifiers = FTDB_ENTRY_STRING(type_entry,qualifiers);
    new_entry->size = FTDB_ENTRY_ULONG(type_entry,size);
    new_entry->str = FTDB_ENTRY_STRING(type_entry,str);
    new_entry->refcount = FTDB_ENTRY_ULONG(type_entry,refcount);
    new_entry->refs_count = FTDB_ENTRY_ARRAY_SIZE(type_entry,refs);
    new_entry->refs = FTDB_ENTRY_ULONG_ARRAY(type_entry,refs);
    new_entry->usedrefs_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(type_entry,usedrefs);
    new_entry->usedrefs = FTDB_ENTRY_INT64_ARRAY_OPTIONAL(type_entry,usedrefs);
    new_entry->decls_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(type_entry,decls);
    new_entry->decls = FTDB_ENTRY_ULONG_ARRAY_OPTIONAL(type_entry,decls);
    new_entry->def = FTDB_ENTRY_STRING_OPTIONAL(type_entry,def);
    new_entry->memberoffsets_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(type_entry,memberoffsets);
    new_entry->memberoffsets = FTDB_ENTRY_ULONG_ARRAY_OPTIONAL(type_entry,memberoffsets);
    new_entry->attrrefs_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(type_entry,attrrefs);
    new_entry->attrrefs = FTDB_ENTRY_ULONG_ARRAY_OPTIONAL(type_entry,attrrefs);
    new_entry->attrnum = FTDB_ENTRY_ULONG_OPTIONAL(type_entry,attrnum);
    new_entry->name = FTDB_ENTRY_STRING_OPTIONAL(type_entry,name);
    new_entry->isdependent = FTDB_ENTRY_BOOL_OPTIONAL(type_entry,dependent);
    new_entry->globalrefs_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(type_entry,globalrefs);
    new_entry->globalrefs = FTDB_ENTRY_ULONG_ARRAY_OPTIONAL(type_entry,globalrefs);
    new_entry->enumvalues_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(type_entry,values);
    new_entry->enumvalues = FTDB_ENTRY_INT64_ARRAY_OPTIONAL(type_entry,values);
    new_entry->outerfn = FTDB_ENTRY_STRING_OPTIONAL(type_entry,outerfn);
    new_entry->outerfnid = FTDB_ENTRY_ULONG_OPTIONAL(type_entry,outerfnid);
    new_entry->isimplicit = FTDB_ENTRY_BOOL_OPTIONAL(type_entry,implicit);
    new_entry->isunion = FTDB_ENTRY_BOOL_OPTIONAL(type_entry,union);
    new_entry->refnames_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(type_entry,refnames);
    new_entry->refnames = FTDB_ENTRY_STRING_ARRAY_OPTIONAL(type_entry,refnames);
    new_entry->location = FTDB_ENTRY_STRING_OPTIONAL(type_entry,location);
    new_entry->isvariadic = FTDB_ENTRY_BOOL_OPTIONAL(type_entry,variadic);
    new_entry->funrefs_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(type_entry,funrefs);
    new_entry->funrefs = FTDB_ENTRY_ULONG_ARRAY_OPTIONAL(type_entry,funrefs);
    new_entry->useddef_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(type_entry,useddef);
    new_entry->useddef = FTDB_ENTRY_STRING_ARRAY_OPTIONAL(type_entry,useddef);
    new_entry->defhead = FTDB_ENTRY_STRING_OPTIONAL(type_entry,defhead);
    new_entry->identifiers_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(type_entry,identifiers);
    new_entry->identifiers = FTDB_ENTRY_STRING_ARRAY_OPTIONAL(type_entry,identifiers);
    new_entry->methods_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(type_entry,methods);
    new_entry->methods = FTDB_ENTRY_ULONG_ARRAY_OPTIONAL(type_entry,methods);

    PyObject* key_bitfields = PyUnicode_FromString("bitfields");
    if (PyDict_Contains(type_entry,key_bitfields)) {
        PyObject* bitfields = PyDict_GetItem(type_entry,key_bitfields);
        PyObject* bitfields_indexes = PyDict_Keys(bitfields);
        new_entry->bitfields_count = PyList_Size(bitfields_indexes);
        new_entry->bitfields = malloc(new_entry->bitfields_count*sizeof(struct bitfield));
        for (Py_ssize_t i=0; i<new_entry->bitfields_count; ++i) {
            PyObject* bf_index = PyList_GetItem(bitfields_indexes,i);
            PyObject* bf_int_index = PyLong_FromString((char*)PyString_get_c_str(bf_index),0,10);
            PyObject* bf_value = PyDict_GetItem(bitfields, bf_index);
            new_entry->bitfields[i].index = PyLong_AsUnsignedLong(bf_int_index);
            new_entry->bitfields[i].bitwidth = PyLong_AsUnsignedLong(bf_value);
        }
        Py_DecRef(bitfields_indexes);
        qsort(new_entry->bitfields,new_entry->bitfields_count,sizeof(struct bitfield),bitfield_compare);
    }
    Py_DecRef(key_bitfields);
}

static void libftdb_create_ftdb_fops_entry(PyObject *self, PyObject* fops_entry, struct ftdb_fops_entry* new_entry) {

    new_entry->kind = FTDB_ENTRY_ENUM_FROM_STRING(fops_entry,kind,fopsKind);
    new_entry->type_id = FTDB_ENTRY_ULONG(fops_entry,type);
    new_entry->var_id = FTDB_ENTRY_ULONG(fops_entry,var);
    new_entry->func_id = FTDB_ENTRY_ULONG(fops_entry,func);
    new_entry->location = FTDB_ENTRY_STRING(fops_entry,loc);
    PyObject* key_members = PyUnicode_FromString("members");
    PyObject* py_members = PyDict_GetItem(fops_entry,key_members);
    Py_DecRef(key_members);
    new_entry->members = calloc(PyDict_Size(py_members),sizeof(struct ftdb_fops_member_entry));
    new_entry->members_count = PyDict_Size(py_members);
    PyObject *member_id, *func_ids;
    Py_ssize_t pos = 0, i = 0;
    while(PyDict_Next(py_members,&pos,&member_id,&func_ids)){
        const char *member_id_str = PyString_get_c_str(member_id);
        PyObject* member_id_int = PyLong_FromString(member_id_str,0,10);
        new_entry->members[i].member_id = PyLong_AsUnsignedLong(member_id_int);
        new_entry->members[i].func_ids = calloc(PyList_Size(func_ids),sizeof(unsigned long));
        new_entry->members[i].func_ids_count = PyList_Size(func_ids);
        for(Py_ssize_t j = 0;j<PyList_Size(func_ids);++j){
            PyObject *py_func_id = PyList_GetItem(func_ids,j);
            new_entry->members[i].func_ids[j] = PyLong_AsUnsignedLong(py_func_id);
        }
        ++i;
    }
}

static void fill_matrix_data_entry(PyObject* matrix_data_entry, struct matrix_data* new_entry) {

    for (Py_ssize_t i=0; i<PyList_Size(matrix_data_entry); ++i) {
        PyObject* entry = PyList_GetItem(matrix_data_entry,i);
        PyObject* key_name = PyUnicode_FromString("name");
        PyObject* name = PyDict_GetItem(entry,key_name);
        Py_DecRef(key_name);
        if (!strcmp(PyString_get_c_str(name),"data")) {
            new_entry->data_count = FTDB_ENTRY_ARRAY_SIZE(entry,data);
            new_entry->data = FTDB_ENTRY_ULONG_ARRAY(entry,data);
        }
        else if (!strcmp(PyString_get_c_str(name),"row_ind")) {
            new_entry->row_ind_count = FTDB_ENTRY_ARRAY_SIZE(entry,data);
            new_entry->row_ind = FTDB_ENTRY_ULONG_ARRAY(entry,data);
        }
        else if (!strcmp(PyString_get_c_str(name),"col_ind")) {
            new_entry->col_ind_count = FTDB_ENTRY_ARRAY_SIZE(entry,data);
            new_entry->col_ind = FTDB_ENTRY_ULONG_ARRAY(entry,data);
        }
        else if (!strcmp(PyString_get_c_str(name),"matrix_size")) {
            new_entry->matrix_size = FTDB_ENTRY_ULONG(entry,data);
        }
    }
}

static void fill_func_map_entry_entry(PyObject* func_map_entry, struct func_map_entry* new_entry) {

    new_entry->id = FTDB_ENTRY_ULONG(func_map_entry,id);
    new_entry->fids_count = FTDB_ENTRY_ARRAY_SIZE(func_map_entry,fids);
    new_entry->fids = FTDB_ENTRY_ULONG_ARRAY(func_map_entry,fids);
}

static void fill_size_dep_item_entry(PyObject* size_dep_item, struct size_dep_item* new_entry) {

    new_entry->id = FTDB_ENTRY_ULONG(size_dep_item,id);
    new_entry->add = FTDB_ENTRY_INT64(size_dep_item,add);
}

static void fill_init_data_item_entry(PyObject* data_item_entry, struct init_data_item* new_entry) {

    new_entry->id = FTDB_ENTRY_ULONG_OPTIONAL(data_item_entry,id);
    new_entry->name_count = FTDB_ENTRY_ARRAY_SIZE(data_item_entry,name);
    new_entry->name = FTDB_ENTRY_STRING_ARRAY(data_item_entry,name);
    new_entry->size = FTDB_ENTRY_ULONG_OPTIONAL(data_item_entry,size);
        new_entry->size_dep = FTDB_ENTRY_TYPE_OPTIONAL(data_item_entry,size_dep,size_dep_item);
    new_entry->nullterminated = FTDB_ENTRY_STRING_OPTIONAL(data_item_entry,nullterminated);
    new_entry->tagged = FTDB_ENTRY_STRING_OPTIONAL(data_item_entry,tagged);
    new_entry->fuzz = FTDB_ENTRY_STRING_OPTIONAL(data_item_entry,fuzz);
    new_entry->pointer = FTDB_ENTRY_STRING_OPTIONAL(data_item_entry,pointer);
    new_entry->min_value = FTDB_ENTRY_INT64_OPTIONAL(data_item_entry,min_value);
    new_entry->max_value = FTDB_ENTRY_INT64_OPTIONAL(data_item_entry,max_value);
    new_entry->value = FTDB_ENTRY_INT64_OPTIONAL(data_item_entry,value);
    new_entry->user_name = FTDB_ENTRY_STRING_OPTIONAL(data_item_entry,user_name);
    new_entry->protected_var = FTDB_ENTRY_STRING_OPTIONAL(data_item_entry,protected);
    new_entry->value_dep_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(data_item_entry,value_dep);
    new_entry->value_dep = FTDB_ENTRY_STRING_ARRAY_OPTIONAL(data_item_entry,value_dep);
    new_entry->fuzz_offset = FTDB_ENTRY_ULONG_OPTIONAL(data_item_entry,fuzz_offset);
    new_entry->force_type = FTDB_ENTRY_STRING_OPTIONAL(data_item_entry,force_type);
    new_entry->always_init_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(data_item_entry,always_init);
    new_entry->always_init = FTDB_ENTRY_STRING_ARRAY_OPTIONAL(data_item_entry,always_init);
    new_entry->subitems_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(data_item_entry,subitems);
    new_entry->subitems = FTDB_ENTRY_TYPE_ARRAY_OPTIONAL(data_item_entry,subitems,init_data_item,new_entry->subitems_count);
}

static void fill_init_data_entry_entry(PyObject* init_data_entry, struct init_data_entry* new_entry) {

    new_entry->name = FTDB_ENTRY_STRING(init_data_entry,name);
    new_entry->order_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(init_data_entry,order);
    new_entry->order = FTDB_ENTRY_ULONG_ARRAY_OPTIONAL(init_data_entry,order);
    new_entry->interface = FTDB_ENTRY_STRING(init_data_entry,interface);
    new_entry->items_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(init_data_entry,items);
    new_entry->items = FTDB_ENTRY_TYPE_ARRAY_OPTIONAL(init_data_entry,items,init_data_item,new_entry->items_count);
}

static void fill_known_data_entry_entry(PyObject* known_data_entry, struct known_data_entry* new_entry) {

    new_entry->version = FTDB_ENTRY_STRING(known_data_entry,version);
    new_entry->func_ids_count = FTDB_ENTRY_ARRAY_SIZE(known_data_entry,func_ids);
    new_entry->func_ids = FTDB_ENTRY_ULONG_ARRAY(known_data_entry,func_ids);
    new_entry->builtin_ids_count = FTDB_ENTRY_ARRAY_SIZE(known_data_entry,builtin_ids);
    new_entry->builtin_ids = FTDB_ENTRY_ULONG_ARRAY(known_data_entry,builtin_ids);
    new_entry->asm_ids_count = FTDB_ENTRY_ARRAY_SIZE(known_data_entry,asm_ids);
    new_entry->asm_ids = FTDB_ENTRY_ULONG_ARRAY(known_data_entry,asm_ids);
    new_entry->lib_funcs_count = FTDB_ENTRY_ARRAY_SIZE(known_data_entry,lib_funcs);
    new_entry->lib_funcs = FTDB_ENTRY_STRING_ARRAY(known_data_entry,lib_funcs);
    new_entry->lib_funcs_ids_count = FTDB_ENTRY_ARRAY_SIZE(known_data_entry,lib_funcs_ids);
    new_entry->lib_funcs_ids = FTDB_ENTRY_ULONG_ARRAY(known_data_entry,lib_funcs_ids);
    new_entry->always_inc_funcs_ids_count = FTDB_ENTRY_ARRAY_SIZE(known_data_entry,always_inc_funcs_ids);
    new_entry->always_inc_funcs_ids = FTDB_ENTRY_ULONG_ARRAY(known_data_entry,always_inc_funcs_ids);
    new_entry->replacement_ids_count = FTDB_ENTRY_ARRAY_SIZE(known_data_entry,replacement_ids);
    new_entry->replacement_ids = FTDB_ENTRY_ULONG_ARRAY(known_data_entry,replacement_ids);
}

static void fill_BAS_item_entry(PyObject* BAS_item_entry, struct BAS_item* new_entry) {

    new_entry->loc = FTDB_ENTRY_STRING(BAS_item_entry,loc);
    new_entry->entries_count = FTDB_ENTRY_ARRAY_SIZE(BAS_item_entry,entries);
    new_entry->entries = FTDB_ENTRY_STRING_ARRAY(BAS_item_entry,entries);
}

static void fill_func_fptrs_entry_entry(PyObject* func_fptrs_item_tuple, struct func_fptrs_entry* new_entry) {

    new_entry->fname = PyString_get_c_str(PyTuple_GetItem(func_fptrs_item_tuple,0));
    PyObject* py_ids = PyTuple_GetItem(func_fptrs_item_tuple,1);
    new_entry->ids_count = PyList_Size(PyTuple_GetItem(func_fptrs_item_tuple,1));
    new_entry->ids = calloc(new_entry->ids_count,sizeof(unsigned long));
    for (unsigned long i=0; i<new_entry->ids_count; ++i) {
        new_entry->ids[i] = PyLong_AsUnsignedLong(PyList_GetItem(py_ids,i));
    }
}

static void fill_func_fptrs_item_entry(PyObject* func_fptrs_item_entry, struct func_fptrs_item* new_entry) {
    new_entry->id = FTDB_ENTRY_ULONG(func_fptrs_item_entry,_id);
    new_entry->entries_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(func_fptrs_item_entry,entries);
    new_entry->entries = FTDB_ENTRY_TYPE_ARRAY_OPTIONAL(func_fptrs_item_entry,entries,func_fptrs_entry,new_entry->entries_count);
}

static void destroy_ftdb(struct ftdb* ftdb) {

    // TODO
}

PyObject * libftdb_create_ftdb(PyObject *self, PyObject *args, PyObject* kwargs) {

    PyObject* dbJSON = PyTuple_GetItem(args,0);
    PyObject* dbfn = PyTuple_GetItem(args,1);
    int show_stats = 0, verbose_mode = 0, debug_mode = 0;
    if (PyTuple_Size(args)>2) {
        PyObject* show_stats_arg = PyTuple_GetItem(args,2);
        if (show_stats_arg==Py_True) {
            show_stats = 1;
        }
    }

    PyObject* py_debug = PyUnicode_FromString("verbose");
    PyObject* py_quiet = PyUnicode_FromString("debug");
    if (kwargs) {
        if (PyDict_Contains(kwargs, py_debug))
            verbose_mode = !!PyLong_AsLong(PyDict_GetItem(kwargs, py_debug));
        if (PyDict_Contains(kwargs, py_quiet))
            debug_mode = !!PyLong_AsLong(PyDict_GetItem(kwargs, py_quiet));
    }
    Py_DecRef(py_debug);
    Py_DecRef(py_quiet);

    struct ftdb ftdb = {0};
    ftdb.db_magic = FTDB_MAGIC_NUMBER;
    ftdb.db_version = FTDB_VERSION;

    PyObject* key_funcs = PyUnicode_FromString("funcs");
    PyObject* funcs = PyDict_GetItem(dbJSON,key_funcs);
    Py_DecRef(key_funcs);
    ftdb.funcs = calloc(PyList_Size(funcs),sizeof(struct ftdb_func_entry));
    ftdb.funcs_count = PyList_Size(funcs);
    for (Py_ssize_t i=0; i<PyList_Size(funcs); ++i) {
        libftdb_create_ftdb_func_entry(self,PyList_GetItem(funcs,i),&ftdb.funcs[i]);
        ftdb.funcs[i].__index = i;
        if (PyErr_Occurred()) {
            printf("Exception while processing function entry at index %ld\n",i);
            PyErr_PrintEx(0);
            PyErr_Clear();
        }
    }

    PyObject* key_funcdecls= PyUnicode_FromString("funcdecls");
    PyObject* funcdecls = PyDict_GetItem(dbJSON,key_funcdecls);
    Py_DecRef(key_funcdecls);
    ftdb.funcdecls = calloc(PyList_Size(funcdecls),sizeof(struct ftdb_funcdecl_entry));
    ftdb.funcdecls_count = PyList_Size(funcdecls);
    for (Py_ssize_t i=0; i<PyList_Size(funcdecls); ++i) {
        libftdb_create_ftdb_funcdecl_entry(self,PyList_GetItem(funcdecls,i),&ftdb.funcdecls[i]);
        ftdb.funcdecls[i].__index = i;
    }

    PyObject* key_unresolvedfuncs= PyUnicode_FromString("unresolvedfuncs");
    PyObject* unresolvedfuncs = PyDict_GetItem(dbJSON,key_unresolvedfuncs);
    Py_DecRef(key_unresolvedfuncs);
    ftdb.unresolvedfuncs = calloc(PyList_Size(unresolvedfuncs),sizeof(struct ftdb_unresolvedfunc_entry));
    ftdb.unresolvedfuncs_count = PyList_Size(unresolvedfuncs);
    for (Py_ssize_t i=0; i<PyList_Size(unresolvedfuncs); ++i) {
        PyObject* py_unresolvedfunc_entry = PyList_GetItem(unresolvedfuncs,i);
        struct ftdb_unresolvedfunc_entry* unresolvedfunc_entry = &ftdb.unresolvedfuncs[i];
        unresolvedfunc_entry->name = FTDB_ENTRY_STRING(py_unresolvedfunc_entry,name);
        unresolvedfunc_entry->id = FTDB_ENTRY_ULONG(py_unresolvedfunc_entry,id);
    }

    PyObject* key_globals = PyUnicode_FromString("globals");
    PyObject* globals = PyDict_GetItem(dbJSON,key_globals);
    Py_DecRef(key_globals);
    ftdb.globals = calloc(PyList_Size(globals),sizeof(struct ftdb_global_entry));
    ftdb.globals_count = PyList_Size(globals);
    for (Py_ssize_t i=0; i<PyList_Size(globals); ++i) {
        libftdb_create_ftdb_global_entry(self,PyList_GetItem(globals,i),&ftdb.globals[i]);
        ftdb.globals[i].__index = i;
    }

    PyObject* key_types = PyUnicode_FromString("types");
    PyObject* types = PyDict_GetItem(dbJSON,key_types);
    Py_DecRef(key_types);
    ftdb.types = calloc(PyList_Size(types),sizeof(struct ftdb_type_entry));
    ftdb.types_count = PyList_Size(types);
    for (Py_ssize_t i=0; i<PyList_Size(types); ++i) {
        libftdb_create_ftdb_type_entry(self,PyList_GetItem(types,i),&ftdb.types[i]);
        ftdb.types[i].__index = i;
    }

    PyObject* key_fops = PyUnicode_FromString("fops");
    PyObject* fops = PyDict_GetItem(dbJSON,key_fops);
    Py_DecRef(key_fops);
    ftdb.fops = calloc(PyList_Size(fops),sizeof(struct ftdb_fops_entry));
    ftdb.fops_count = PyList_Size(fops);
    for (Py_ssize_t i=0; i<PyList_Size(fops); ++i) {
        libftdb_create_ftdb_fops_entry(self,PyList_GetItem(fops,i),&ftdb.fops[i]);
        ftdb.fops[i].__index = i;
    }

    PyObject* key_source_info = PyUnicode_FromString("source_info");
    PyObject* key_sources = PyUnicode_FromString("sources");
    if (PyDict_Contains(dbJSON, key_source_info)) {
        PyObject* sources = PyDict_GetItem(dbJSON,key_source_info);
        ftdb.sourceindex_table = calloc(PyList_Size(sources),sizeof(const char*));
        ftdb.sourceindex_table_count = PyList_Size(sources);
        for (Py_ssize_t i=0; i<PyList_Size(sources); ++i) {
            PyObject* single_source_map = PyList_GetItem(sources,i);
            PyObject* py_source_path = FTDB_ENTRY_PYOBJECT(single_source_map,name);
            PyObject* py_source_id = FTDB_ENTRY_PYOBJECT(single_source_map,id);
            stringRefMap_insert(&ftdb.sourcemap, PyString_get_c_str(py_source_path), PyLong_AsUnsignedLong(py_source_id));
            ftdb.sourceindex_table[PyLong_AsUnsignedLong(py_source_id)] = PyString_get_c_str(py_source_path);
        }
    }
    else if (PyDict_Contains(dbJSON, key_sources)) {
        PyObject* sources = PyDict_GetItem(dbJSON,key_sources);
        ftdb.sourceindex_table = calloc(PyList_Size(sources),sizeof(const char*));
        ftdb.sourceindex_table_count = PyList_Size(sources);
        for (Py_ssize_t i=0; i<PyList_Size(sources); ++i) {
            PyObject* single_source_legacy_map = PyList_GetItem(sources,i);
            PyObject* sslm_keys = PyDict_Keys(single_source_legacy_map);
            PyObject* py_source_path = PyList_GetItem(sslm_keys,0);
            PyObject* py_source_id = PyDict_GetItem(single_source_legacy_map,py_source_path);
            Py_DecRef(sslm_keys);
            stringRefMap_insert(&ftdb.sourcemap, PyString_get_c_str(py_source_path), PyLong_AsUnsignedLong(py_source_id));
            ftdb.sourceindex_table[PyLong_AsUnsignedLong(py_source_id)] = PyString_get_c_str(py_source_path);
        }
    }
    else {
        PyErr_SetString(libftdb_ftdbError,"ERROR: missing ftdb table \"source_info\"/\"sources\"");
        Py_DecRef(key_source_info);
        Py_DecRef(key_sources);
        Py_RETURN_NONE;
    }
    Py_DecRef(key_source_info);
    Py_DecRef(key_sources);

    PyObject* key_module_info = PyUnicode_FromString("module_info");
    PyObject* key_modules = PyUnicode_FromString("modules");
    if (PyDict_Contains(dbJSON, key_module_info)) {
        PyObject* modules = PyDict_GetItem(dbJSON,key_module_info);
        ftdb.moduleindex_table = calloc(PyList_Size(modules),sizeof(const char*));
        ftdb.moduleindex_table_count = PyList_Size(modules);
        for (Py_ssize_t i=0; i<PyList_Size(modules); ++i) {
            PyObject* single_module_map = PyList_GetItem(modules,i);
            PyObject* py_module_path = FTDB_ENTRY_PYOBJECT(single_module_map,name);
            PyObject* py_module_id = FTDB_ENTRY_PYOBJECT(single_module_map,id);
            stringRefMap_insert(&ftdb.modulemap, PyString_get_c_str(py_module_path), PyLong_AsUnsignedLong(py_module_id));
            ftdb.moduleindex_table[PyLong_AsUnsignedLong(py_module_id)] = PyString_get_c_str(py_module_path);
        }
    }
    else if (PyDict_Contains(dbJSON, key_modules)) {
        PyObject* modules = PyDict_GetItem(dbJSON,key_modules);
        ftdb.moduleindex_table = calloc(PyList_Size(modules),sizeof(const char*));
        ftdb.moduleindex_table_count = PyList_Size(modules);
        for (Py_ssize_t i=0; i<PyList_Size(modules); ++i) {
            PyObject* single_module_legacy_map = PyList_GetItem(modules,i);
            PyObject* smlm_keys = PyDict_Keys(single_module_legacy_map);
            PyObject* py_module_path = PyList_GetItem(smlm_keys,0);
            PyObject* py_module_id = PyDict_GetItem(single_module_legacy_map,py_module_path);
            Py_DecRef(smlm_keys);
            stringRefMap_insert(&ftdb.modulemap, PyString_get_c_str(py_module_path), PyLong_AsUnsignedLong(py_module_id));
            ftdb.moduleindex_table[PyLong_AsUnsignedLong(py_module_id)] = PyString_get_c_str(py_module_path);
        }
    }
    Py_DecRef(key_module_info);
    Py_DecRef(key_modules);

    ftdb.version = FTDB_ENTRY_STRING(dbJSON,version);
    ftdb.module = FTDB_ENTRY_STRING(dbJSON,module);
    ftdb.directory = FTDB_ENTRY_STRING(dbJSON,directory);
    ftdb.release = FTDB_ENTRY_STRING(dbJSON,release);

    ftdb.funcs_tree_calls_no_asm = FTDB_ENTRY_TYPE_OPTIONAL(dbJSON,funcs_tree_calls_no_asm,matrix_data);
    ftdb.funcs_tree_calls_no_known = FTDB_ENTRY_TYPE_OPTIONAL(dbJSON,funcs_tree_calls_no_known,matrix_data);
    ftdb.funcs_tree_calls_no_known_no_asm = FTDB_ENTRY_TYPE_OPTIONAL(dbJSON,funcs_tree_calls_no_known_no_asm,matrix_data);
    ftdb.funcs_tree_func_calls = FTDB_ENTRY_TYPE_OPTIONAL(dbJSON,funcs_tree_func_calls,matrix_data);
    ftdb.funcs_tree_func_refs = FTDB_ENTRY_TYPE_OPTIONAL(dbJSON,funcs_tree_func_refs,matrix_data);
    ftdb.funcs_tree_funrefs_no_asm = FTDB_ENTRY_TYPE_OPTIONAL(dbJSON,funcs_tree_funrefs_no_asm,matrix_data);
    ftdb.funcs_tree_funrefs_no_known = FTDB_ENTRY_TYPE_OPTIONAL(dbJSON,funcs_tree_funrefs_no_known,matrix_data);
    ftdb.funcs_tree_funrefs_no_known_no_asm = FTDB_ENTRY_TYPE_OPTIONAL(dbJSON,funcs_tree_funrefs_no_known_no_asm,matrix_data);
    ftdb.globs_tree_globalrefs = FTDB_ENTRY_TYPE_OPTIONAL(dbJSON,globs_tree_globalrefs,matrix_data);
    ftdb.types_tree_refs = FTDB_ENTRY_TYPE_OPTIONAL(dbJSON,types_tree_refs,matrix_data);
    ftdb.types_tree_usedrefs = FTDB_ENTRY_TYPE_OPTIONAL(dbJSON,types_tree_usedrefs,matrix_data);
    ftdb.static_funcs_map_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(dbJSON,static_funcs_map);
    ftdb.static_funcs_map = FTDB_ENTRY_TYPE_ARRAY_OPTIONAL(dbJSON,static_funcs_map,func_map_entry,ftdb.static_funcs_map_count);
    ftdb.init_data_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(dbJSON,init_data);
    ftdb.init_data = FTDB_ENTRY_TYPE_ARRAY_OPTIONAL(dbJSON,init_data,init_data_entry,ftdb.init_data_count);
    ftdb.known_data = FTDB_ENTRY_TYPE_ARRAY_OPTIONAL(dbJSON,known_data,known_data_entry,1);
    ftdb.BAS_data_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(dbJSON,BAS);
    ftdb.BAS_data = FTDB_ENTRY_TYPE_ARRAY_OPTIONAL(dbJSON,BAS,BAS_item,ftdb.BAS_data_count);
    ftdb.func_fptrs_data_count = FTDB_ENTRY_ARRAY_SIZE_OPTIONAL(dbJSON,func_fptrs);
    ftdb.func_fptrs_data = FTDB_ENTRY_TYPE_ARRAY_OPTIONAL(dbJSON,func_fptrs,func_fptrs_item,ftdb.func_fptrs_data_count);

    int ok = ftdb_maps(&ftdb,show_stats);
    (void)ok;

    for (unsigned long i=0; i<ftdb.static_funcs_map_count; ++i) {
        struct func_map_entry* entry = &ftdb.static_funcs_map[i];
        ulong_entryMap_insert(&ftdb.static_funcs_map_index,entry->id,entry);
    }
    printf("static_funcs_map_index keys: %zu\n",ulong_entryMap_count(&ftdb.static_funcs_map_index));

    for (unsigned long i=0; i<ftdb.BAS_data_count; ++i) {
        struct BAS_item* item = &ftdb.BAS_data[i];
        stringRef_entryMap_insert(&ftdb.BAS_data_index,item->loc,item);
    }
    printf("BAS_data_index keys: %zu\n",stringRef_entryMap_count(&ftdb.BAS_data_index));

    printf("funcs count: %ld\n",PyList_Size(funcs));
    printf("funcs entry count: %zu\n",ftdb.funcs_count);
    printf("funcdecls count: %ld\n",PyList_Size(funcdecls));
    printf("funcdecls entry count: %zu\n",ftdb.funcdecls_count);
    printf("unresolvedfuncs count: %ld\n",PyList_Size(unresolvedfuncs));
    printf("unresolvedfuncs entry count: %zu\n",ftdb.unresolvedfuncs_count);
    printf("globals count: %ld\n",PyList_Size(globals));
    printf("globals entry count: %zu\n",ftdb.globals_count);
    printf("types count: %ld\n",PyList_Size(types));
    printf("types entry count: %zu\n",ftdb.types_count);
    printf("fops count: %ld\n",PyList_Size(fops));
    printf("fops entry count: %zu\n",ftdb.fops_count);
    if (ftdb.funcs_tree_calls_no_asm) printf("funcs_tree_calls_no_asm: OK\n");
    if (ftdb.funcs_tree_calls_no_known) printf("funcs_tree_calls_no_known: OK\n");
    if (ftdb.funcs_tree_calls_no_known_no_asm) printf("funcs_tree_calls_no_known_no_asm: OK\n");
    if (ftdb.funcs_tree_func_calls) printf("funcs_tree_func_calls: OK\n");
    if (ftdb.funcs_tree_func_refs) printf("funcs_tree_func_refs: OK\n");
    if (ftdb.funcs_tree_funrefs_no_asm) printf("funcs_tree_funrefs_no_asm: OK\n");
    if (ftdb.funcs_tree_funrefs_no_known) printf("funcs_tree_funrefs_no_known: OK\n");
    if (ftdb.funcs_tree_funrefs_no_known_no_asm) printf("funcs_tree_funrefs_no_known_no_asm: OK\n");
    if (ftdb.globs_tree_globalrefs) printf("globs_tree_globalrefs: OK\n");
    if (ftdb.types_tree_refs) printf("types_tree_refs: OK\n");
    if (ftdb.types_tree_usedrefs) printf("types_tree_usedrefs: OK\n");
    if (ftdb.static_funcs_map) printf("static_funcs_map [%lu]: OK\n",ftdb.static_funcs_map_count);
    if (ftdb.init_data) printf("init_data [%lu]: OK\n",ftdb.init_data_count);
    if (ftdb.known_data) printf("known_data: OK\n");
    if (ftdb.BAS_data) printf("BAS_data [%lu]: OK\n",ftdb.BAS_data_count);
    if (ftdb.func_fptrs_data) printf("func_fptrs_data [%lu]: OK\n",ftdb.func_fptrs_data_count);

    const char* dbfn_s =  PyString_get_c_str(dbfn);
    struct uflat* uflat = uflat_init(dbfn_s);
    PYASSTR_DECREF(dbfn_s);
    if(uflat == NULL) {
        printf("uflat_init(): failed\n");
        Py_RETURN_FALSE;
    }

    int rv = uflat_set_option(uflat, UFLAT_OPT_OUTPUT_SIZE, 50ULL * 1024 * 1024 * 1024);
    if(rv) {
        printf("uflat_set_option(OUTPUT_SIZE): %d\n", rv);
        goto uflat_error_exit;
    }

    rv = uflat_set_option(uflat, UFLAT_OPT_SKIP_MEM_FRAGMENTS, 1);
    if(rv) {
        printf("uflat_set_option(SKIP_MEM_FRAGMENTS): %d\n", rv);
        goto uflat_error_exit;
    }

    uflat_set_option(uflat, UFLAT_OPT_SKIP_MEM_COPY, 1);

    if(verbose_mode)
        uflat_set_option(uflat, UFLAT_OPT_VERBOSE, 1);
    if(debug_mode)
        uflat_set_option(uflat, UFLAT_OPT_DEBUG, 1);

    FOR_ROOT_POINTER(&ftdb,
        FLATTEN_STRUCT(ftdb,&ftdb);
    );

    int err = uflat_write(uflat);
    if (err != 0) {
        printf("flatten_write(): %d\n", err);
        goto uflat_error_exit;
    }

    uflat_fini(uflat);
    destroy_ftdb(&ftdb);
    Py_RETURN_NONE;

uflat_error_exit:
    uflat_fini(uflat);
    destroy_ftdb(&ftdb);
    Py_RETURN_FALSE;
}

PyObject * libftdb_parse_c_fmt_string(PyObject *self, PyObject *args) {

    const char* fmt;
    if(!PyArg_ParseTuple(args, "s", &fmt))
        return NULL;
        
    enum format_type* par_type = malloc(256*sizeof(enum format_type));
    int n = vsnprintf_parse_format(&par_type,256,fmt);

    if (n<0) {
        free(par_type);
        Py_RETURN_NONE;
    }

    PyObject* argv = PyList_New(0);
    for (int i=0; i<n; ++i) {
        enum format_type v = par_type[i];
        PyList_Append(argv,PyLong_FromLong((long)v));
    }

    free(par_type);
    return argv;
}

PyMODINIT_FUNC
PyInit_libftdb(void)
{
    PyObject* m;

    m = PyModule_Create(&libftdb_module);
    if (m==0) return 0;

    if (PyType_Ready(&libftdb_ftdbType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbType);

    if (PyType_Ready(&libftdb_ftdbSourcesType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbSourcesType);

    if (PyType_Ready(&libftdb_ftdbModulesType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbModulesType);

    if (PyType_Ready(&libftdb_ftdbFuncsType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbFuncsType);

    if (PyType_Ready(&libftdb_ftdbFuncdeclsType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbFuncdeclsType);

    if (PyType_Ready(&libftdb_ftdbUnresolvedfuncsType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbUnresolvedfuncsType);

    if (PyType_Ready(&libftdb_ftdbGlobalsType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbGlobalsType);

    if (PyType_Ready(&libftdb_ftdbTypesType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbTypesType);

    if (PyType_Ready(&libftdb_ftdbFopsType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbFopsType);

    if (PyType_Ready(&libftdb_ftdbSourcesIterType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbSourcesIterType);

    if (PyType_Ready(&libftdb_ftdbModulesIterType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbModulesIterType);

    if (PyType_Ready(&libftdb_ftdbFuncsIterType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbFuncsIterType);

    if (PyType_Ready(&libftdb_ftdbFuncdeclsIterType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbFuncdeclsIterType);

    if (PyType_Ready(&libftdb_ftdbUnresolvedfuncsIterType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbUnresolvedfuncsIterType);

    if (PyType_Ready(&libftdb_ftdbGlobalsIterType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbGlobalsIterType);

    if (PyType_Ready(&libftdb_ftdbTypesIterType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbTypesIterType);

    if (PyType_Ready(&libftdb_ftdbFopsIterType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbFopsIterType);

    if (PyType_Ready(&libftdb_ftdbFuncsEntryType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbFuncsEntryType);

    if (PyType_Ready(&libftdb_ftdbFuncdeclsEntryType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbFuncdeclsEntryType);

    if (PyType_Ready(&libftdb_ftdbGlobalEntryType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbGlobalEntryType);

    if (PyType_Ready(&libftdb_ftdbTypeEntryType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbTypeEntryType);

    if (PyType_Ready(&libftdb_ftdbFopsEntryType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbFopsEntryType);

    if (PyType_Ready(&libftdb_ftdbFuncCallInfoEntryType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbFuncCallInfoEntryType);

    if (PyType_Ready(&libftdb_ftdbFuncSwitchInfoEntryType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbFuncSwitchInfoEntryType);

    if (PyType_Ready(&libftdb_ftdbFuncIfInfoEntryType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbFuncIfInfoEntryType);

    if (PyType_Ready(&libftdb_ftdbFuncLocalInfoEntryType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbFuncLocalInfoEntryType);

    if (PyType_Ready(&libftdb_ftdbFuncDerefInfoEntryType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbFuncDerefInfoEntryType);

    if (PyType_Ready(&libftdb_ftdbFuncOffsetrefInfoEntryType) < 0)
        return 0;
    Py_XINCREF(&libftdb_ftdbFuncOffsetrefInfoEntryType);

    if (PyModule_AddObject(m, "ftdb", (PyObject *)&libftdb_ftdbType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbModules", (PyObject *)&libftdb_ftdbModulesType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbModulesIter", (PyObject *)&libftdb_ftdbModulesIterType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbSources", (PyObject *)&libftdb_ftdbSourcesType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbSourcesIter", (PyObject *)&libftdb_ftdbSourcesIterType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbFuncs", (PyObject *)&libftdb_ftdbFuncsType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbFuncsIter", (PyObject *)&libftdb_ftdbFuncsIterType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbFuncEntry", (PyObject *)&libftdb_ftdbFuncsEntryType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbFuncCallInfoEntry", (PyObject *)&libftdb_ftdbFuncCallInfoEntryType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbFuncSwitchInfoEntry", (PyObject *)&libftdb_ftdbFuncSwitchInfoEntryType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbFuncIfInfoEntry", (PyObject *)&libftdb_ftdbFuncIfInfoEntryType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbFuncLocalInfoEntry", (PyObject *)&libftdb_ftdbFuncLocalInfoEntryType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbFuncDerefInfoEntry", (PyObject *)&libftdb_ftdbFuncDerefInfoEntryType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbFuncOffsetrefInfoEntry", (PyObject *)&libftdb_ftdbFuncOffsetrefInfoEntryType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbFuncdecls", (PyObject *)&libftdb_ftdbFuncdeclsType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbFuncdeclEntry", (PyObject *)&libftdb_ftdbFuncdeclsEntryType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbUnresolvedfuncs", (PyObject *)&libftdb_ftdbUnresolvedfuncsType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbUnresolvedfuncsIter", (PyObject *)&libftdb_ftdbUnresolvedfuncsIterType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbGlobals", (PyObject *)&libftdb_ftdbGlobalsType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbGlobalsIter", (PyObject *)&libftdb_ftdbGlobalsIterType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbGlobalEntry", (PyObject *)&libftdb_ftdbGlobalEntryType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbTypes", (PyObject *)&libftdb_ftdbTypesType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbTypesIter", (PyObject *)&libftdb_ftdbTypesIterType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbTypeEntry", (PyObject *)&libftdb_ftdbTypeEntryType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbFops", (PyObject *)&libftdb_ftdbFopsType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbFopsIter", (PyObject *)&libftdb_ftdbFopsIterType)<0) {
        Py_DECREF(m);
        return 0;
    }

    if (PyModule_AddObject(m, "ftdbFopsEntry", (PyObject *)&libftdb_ftdbFopsEntryType)<0) {
        Py_DECREF(m);
        return 0;
    }

    libftdb_ftdbError = PyErr_NewException("libftdb.FtdbError",0,0);
    Py_XINCREF(libftdb_ftdbError);
    if (PyModule_AddObject(m, "FtdbError", libftdb_ftdbError) < 0) {
        Py_XDECREF(libftdb_ftdbError);
        Py_CLEAR(libftdb_ftdbError);
        Py_DECREF(m);
    }

    return m;
}