deusdata--codebase-memory-mcp/internal/cbm/lsp/generated/python_stdlib_data.c

// AUTO-GENERATED by scripts/gen-py-stdlib.py — DO NOT EDIT
// Python stdlib type information for LSP type resolver.
//
// Source: typeshed commit a7912d521e16ff63caf7a8b64b9072542be36777
// Module allowlist: see ALLOWED_MODULES in scripts/gen-py-stdlib.py
//
// v1 simplifications (per PYTHON_LSP_PLAN.md Phase 10):
//   - overload stacks collapse to first signature
//   - ParamSpec / TypeVarTuple / Concatenate skipped
//   - version guards flattened (union of all branches)
//   - per-symbol min/max version guards not yet emitted

#include "../type_rep.h"
#include "../type_registry.h"
#include <string.h>

#define CBM_PYTHON_STDLIB_GENERATED 1

void cbm_python_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) {
    if (!reg || !arena) return;

    CBMRegisteredType rt;
    CBMRegisteredFunc rf;

    /* ===== module: _collections_abc ===== */
    static const char* py_methods_1[] = { "isdisjoint", "mapping", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "_collections_abc.dict_keys";
    rt.short_name = "dict_keys";
    rt.method_names = py_methods_1;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "_collections_abc.dict_keys.isdisjoint";
    rf.short_name = "isdisjoint";
    rf.receiver_type = "_collections_abc.dict_keys";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "_collections_abc.dict_keys.mapping";
    rf.short_name = "mapping";
    rf.receiver_type = "_collections_abc.dict_keys";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_2[] = { "mapping", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "_collections_abc.dict_values";
    rt.short_name = "dict_values";
    rt.method_names = py_methods_2;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "_collections_abc.dict_values.mapping";
    rf.short_name = "mapping";
    rf.receiver_type = "_collections_abc.dict_values";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_3[] = { "isdisjoint", "mapping", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "_collections_abc.dict_items";
    rt.short_name = "dict_items";
    rt.method_names = py_methods_3;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "_collections_abc.dict_items.isdisjoint";
    rf.short_name = "isdisjoint";
    rf.receiver_type = "_collections_abc.dict_items";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "_collections_abc.dict_items.mapping";
    rf.short_name = "mapping";
    rf.receiver_type = "_collections_abc.dict_items";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "_collections_abc.Buffer";
    rt.short_name = "Buffer";
    static const char* py_bases_4[] = { "_collections_abc.Protocol", NULL };
    rt.embedded_types = py_bases_4;
    cbm_registry_add_type(reg, rt);

    /* ===== module: abc ===== */
    static const char* py_methods_5[] = { "__new__", "register", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "abc.ABCMeta";
    rt.short_name = "ABCMeta";
    rt.method_names = py_methods_5;
    static const char* py_bases_6[] = { "abc.type", NULL };
    rt.embedded_types = py_bases_6;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "abc.ABCMeta.__new__";
    rf.short_name = "__new__";
    rf.receiver_type = "abc.ABCMeta";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "abc.ABCMeta.register";
    rf.short_name = "register";
    rf.receiver_type = "abc.ABCMeta";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_7[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "abc.abstractclassmethod";
    rt.short_name = "abstractclassmethod";
    rt.method_names = py_methods_7;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "abc.abstractclassmethod.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "abc.abstractclassmethod";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_8[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "abc.abstractstaticmethod";
    rt.short_name = "abstractstaticmethod";
    rt.method_names = py_methods_8;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "abc.abstractstaticmethod.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "abc.abstractstaticmethod";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "abc.abstractproperty";
    rt.short_name = "abstractproperty";
    static const char* py_bases_9[] = { "abc.property", NULL };
    rt.embedded_types = py_bases_9;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "abc.ABC";
    rt.short_name = "ABC";
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "abc.abstractmethod";
    rf.short_name = "abstractmethod";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "abc.get_cache_token";
    rf.short_name = "get_cache_token";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "abc.update_abstractmethods";
    rf.short_name = "update_abstractmethods";
    cbm_registry_add_func(reg, rf);

    /* ===== module: argparse ===== */
    static const char* py_methods_10[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse.ArgumentError";
    rt.short_name = "ArgumentError";
    rt.method_names = py_methods_10;
    static const char* py_bases_11[] = { "argparse.Exception", NULL };
    rt.embedded_types = py_bases_11;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.ArgumentError.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "argparse.ArgumentError";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse._AttributeHolder";
    rt.short_name = "_AttributeHolder";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_12[] = { "__init__", "register", "set_defaults", "get_default", "add_argument", "add_argument_group", "add_mutually_exclusive_group", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse._ActionsContainer";
    rt.short_name = "_ActionsContainer";
    rt.method_names = py_methods_12;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse._ActionsContainer.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "argparse._ActionsContainer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse._ActionsContainer.register";
    rf.short_name = "register";
    rf.receiver_type = "argparse._ActionsContainer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse._ActionsContainer.set_defaults";
    rf.short_name = "set_defaults";
    rf.receiver_type = "argparse._ActionsContainer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse._ActionsContainer.get_default";
    rf.short_name = "get_default";
    rf.receiver_type = "argparse._ActionsContainer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse._ActionsContainer.add_argument";
    rf.short_name = "add_argument";
    rf.receiver_type = "argparse._ActionsContainer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse._ActionsContainer.add_argument_group";
    rf.short_name = "add_argument_group";
    rf.receiver_type = "argparse._ActionsContainer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse._ActionsContainer.add_mutually_exclusive_group";
    rf.short_name = "add_mutually_exclusive_group";
    rf.receiver_type = "argparse._ActionsContainer";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_13[] = { "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse._FormatterClass";
    rt.short_name = "_FormatterClass";
    rt.method_names = py_methods_13;
    static const char* py_bases_14[] = { "argparse.Protocol", NULL };
    rt.embedded_types = py_bases_14;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse._FormatterClass.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "argparse._FormatterClass";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_15[] = { "__init__", "parse_args", "add_subparsers", "print_usage", "print_help", "format_usage", "format_help", "parse_known_args", "convert_arg_line_to_args", "exit", "error", "parse_intermixed_args", "parse_known_intermixed_args", "_parse_known_args", "_parse_optional", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse.ArgumentParser";
    rt.short_name = "ArgumentParser";
    rt.method_names = py_methods_15;
    static const char* py_bases_16[] = { "argparse._AttributeHolder", "argparse._ActionsContainer", NULL };
    rt.embedded_types = py_bases_16;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.ArgumentParser.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "argparse.ArgumentParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.ArgumentParser.parse_args";
    rf.short_name = "parse_args";
    rf.receiver_type = "argparse.ArgumentParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.ArgumentParser.add_subparsers";
    rf.short_name = "add_subparsers";
    rf.receiver_type = "argparse.ArgumentParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.ArgumentParser.print_usage";
    rf.short_name = "print_usage";
    rf.receiver_type = "argparse.ArgumentParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.ArgumentParser.print_help";
    rf.short_name = "print_help";
    rf.receiver_type = "argparse.ArgumentParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.ArgumentParser.format_usage";
    rf.short_name = "format_usage";
    rf.receiver_type = "argparse.ArgumentParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.ArgumentParser.format_help";
    rf.short_name = "format_help";
    rf.receiver_type = "argparse.ArgumentParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.ArgumentParser.parse_known_args";
    rf.short_name = "parse_known_args";
    rf.receiver_type = "argparse.ArgumentParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.ArgumentParser.convert_arg_line_to_args";
    rf.short_name = "convert_arg_line_to_args";
    rf.receiver_type = "argparse.ArgumentParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.ArgumentParser.exit";
    rf.short_name = "exit";
    rf.receiver_type = "argparse.ArgumentParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.ArgumentParser.error";
    rf.short_name = "error";
    rf.receiver_type = "argparse.ArgumentParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.ArgumentParser.parse_intermixed_args";
    rf.short_name = "parse_intermixed_args";
    rf.receiver_type = "argparse.ArgumentParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.ArgumentParser.parse_known_intermixed_args";
    rf.short_name = "parse_known_intermixed_args";
    rf.receiver_type = "argparse.ArgumentParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.ArgumentParser._parse_known_args";
    rf.short_name = "_parse_known_args";
    rf.receiver_type = "argparse.ArgumentParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.ArgumentParser._parse_optional";
    rf.short_name = "_parse_optional";
    rf.receiver_type = "argparse.ArgumentParser";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_17[] = { "__init__", "start_section", "end_section", "add_text", "add_usage", "add_argument", "add_arguments", "format_help", "_format_actions_usage", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse.HelpFormatter";
    rt.short_name = "HelpFormatter";
    rt.method_names = py_methods_17;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.HelpFormatter.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "argparse.HelpFormatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.HelpFormatter.start_section";
    rf.short_name = "start_section";
    rf.receiver_type = "argparse.HelpFormatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.HelpFormatter.end_section";
    rf.short_name = "end_section";
    rf.receiver_type = "argparse.HelpFormatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.HelpFormatter.add_text";
    rf.short_name = "add_text";
    rf.receiver_type = "argparse.HelpFormatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.HelpFormatter.add_usage";
    rf.short_name = "add_usage";
    rf.receiver_type = "argparse.HelpFormatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.HelpFormatter.add_argument";
    rf.short_name = "add_argument";
    rf.receiver_type = "argparse.HelpFormatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.HelpFormatter.add_arguments";
    rf.short_name = "add_arguments";
    rf.receiver_type = "argparse.HelpFormatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.HelpFormatter.format_help";
    rf.short_name = "format_help";
    rf.receiver_type = "argparse.HelpFormatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.HelpFormatter._format_actions_usage";
    rf.short_name = "_format_actions_usage";
    rf.receiver_type = "argparse.HelpFormatter";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse.RawDescriptionHelpFormatter";
    rt.short_name = "RawDescriptionHelpFormatter";
    static const char* py_bases_18[] = { "argparse.HelpFormatter", NULL };
    rt.embedded_types = py_bases_18;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse.RawTextHelpFormatter";
    rt.short_name = "RawTextHelpFormatter";
    static const char* py_bases_19[] = { "argparse.RawDescriptionHelpFormatter", NULL };
    rt.embedded_types = py_bases_19;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse.ArgumentDefaultsHelpFormatter";
    rt.short_name = "ArgumentDefaultsHelpFormatter";
    static const char* py_bases_20[] = { "argparse.HelpFormatter", NULL };
    rt.embedded_types = py_bases_20;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse.MetavarTypeHelpFormatter";
    rt.short_name = "MetavarTypeHelpFormatter";
    static const char* py_bases_21[] = { "argparse.HelpFormatter", NULL };
    rt.embedded_types = py_bases_21;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_22[] = { "__init__", "__call__", "format_usage", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse.Action";
    rt.short_name = "Action";
    rt.method_names = py_methods_22;
    static const char* py_bases_23[] = { "argparse._AttributeHolder", NULL };
    rt.embedded_types = py_bases_23;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.Action.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "argparse.Action";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.Action.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "argparse.Action";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.Action.format_usage";
    rf.short_name = "format_usage";
    rf.receiver_type = "argparse.Action";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_24[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse.BooleanOptionalAction";
    rt.short_name = "BooleanOptionalAction";
    rt.method_names = py_methods_24;
    static const char* py_bases_25[] = { "argparse.Action", NULL };
    rt.embedded_types = py_bases_25;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.BooleanOptionalAction.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "argparse.BooleanOptionalAction";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_26[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse.BooleanOptionalAction";
    rt.short_name = "BooleanOptionalAction";
    rt.method_names = py_methods_26;
    static const char* py_bases_27[] = { "argparse.Action", NULL };
    rt.embedded_types = py_bases_27;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.BooleanOptionalAction.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "argparse.BooleanOptionalAction";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_28[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse.Namespace";
    rt.short_name = "Namespace";
    rt.method_names = py_methods_28;
    static const char* py_bases_29[] = { "argparse._AttributeHolder", NULL };
    rt.embedded_types = py_bases_29;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.Namespace.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "argparse.Namespace";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_30[] = { "__init__", "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse.FileType";
    rt.short_name = "FileType";
    rt.method_names = py_methods_30;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.FileType.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "argparse.FileType";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.FileType.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "argparse.FileType";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_31[] = { "__init__", "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse.FileType";
    rt.short_name = "FileType";
    rt.method_names = py_methods_31;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.FileType.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "argparse.FileType";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse.FileType.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "argparse.FileType";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_32[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse._ArgumentGroup";
    rt.short_name = "_ArgumentGroup";
    rt.method_names = py_methods_32;
    static const char* py_bases_33[] = { "argparse._ActionsContainer", NULL };
    rt.embedded_types = py_bases_33;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse._ArgumentGroup.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "argparse._ArgumentGroup";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_34[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse._MutuallyExclusiveGroup";
    rt.short_name = "_MutuallyExclusiveGroup";
    rt.method_names = py_methods_34;
    static const char* py_bases_35[] = { "argparse._ArgumentGroup", NULL };
    rt.embedded_types = py_bases_35;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse._MutuallyExclusiveGroup.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "argparse._MutuallyExclusiveGroup";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse._StoreAction";
    rt.short_name = "_StoreAction";
    static const char* py_bases_36[] = { "argparse.Action", NULL };
    rt.embedded_types = py_bases_36;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_37[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse._StoreConstAction";
    rt.short_name = "_StoreConstAction";
    rt.method_names = py_methods_37;
    static const char* py_bases_38[] = { "argparse.Action", NULL };
    rt.embedded_types = py_bases_38;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse._StoreConstAction.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "argparse._StoreConstAction";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_39[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse._StoreTrueAction";
    rt.short_name = "_StoreTrueAction";
    rt.method_names = py_methods_39;
    static const char* py_bases_40[] = { "argparse._StoreConstAction", NULL };
    rt.embedded_types = py_bases_40;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse._StoreTrueAction.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "argparse._StoreTrueAction";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_41[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse._StoreFalseAction";
    rt.short_name = "_StoreFalseAction";
    rt.method_names = py_methods_41;
    static const char* py_bases_42[] = { "argparse._StoreConstAction", NULL };
    rt.embedded_types = py_bases_42;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse._StoreFalseAction.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "argparse._StoreFalseAction";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse._AppendAction";
    rt.short_name = "_AppendAction";
    static const char* py_bases_43[] = { "argparse.Action", NULL };
    rt.embedded_types = py_bases_43;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse._ExtendAction";
    rt.short_name = "_ExtendAction";
    static const char* py_bases_44[] = { "argparse._AppendAction", NULL };
    rt.embedded_types = py_bases_44;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_45[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse._AppendConstAction";
    rt.short_name = "_AppendConstAction";
    rt.method_names = py_methods_45;
    static const char* py_bases_46[] = { "argparse.Action", NULL };
    rt.embedded_types = py_bases_46;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse._AppendConstAction.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "argparse._AppendConstAction";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_47[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse._CountAction";
    rt.short_name = "_CountAction";
    rt.method_names = py_methods_47;
    static const char* py_bases_48[] = { "argparse.Action", NULL };
    rt.embedded_types = py_bases_48;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse._CountAction.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "argparse._CountAction";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_49[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse._HelpAction";
    rt.short_name = "_HelpAction";
    rt.method_names = py_methods_49;
    static const char* py_bases_50[] = { "argparse.Action", NULL };
    rt.embedded_types = py_bases_50;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse._HelpAction.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "argparse._HelpAction";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_51[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse._VersionAction";
    rt.short_name = "_VersionAction";
    rt.method_names = py_methods_51;
    static const char* py_bases_52[] = { "argparse.Action", NULL };
    rt.embedded_types = py_bases_52;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse._VersionAction.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "argparse._VersionAction";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_53[] = { "__init__", "add_parser", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse._SubParsersAction";
    rt.short_name = "_SubParsersAction";
    rt.method_names = py_methods_53;
    static const char* py_bases_54[] = { "argparse.Action", NULL };
    rt.embedded_types = py_bases_54;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse._SubParsersAction.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "argparse._SubParsersAction";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "argparse._SubParsersAction.add_parser";
    rf.short_name = "add_parser";
    rf.receiver_type = "argparse._SubParsersAction";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "argparse.ArgumentTypeError";
    rt.short_name = "ArgumentTypeError";
    static const char* py_bases_55[] = { "argparse.Exception", NULL };
    rt.embedded_types = py_bases_55;
    cbm_registry_add_type(reg, rt);

    /* ===== module: asyncio ===== */
    static const char* py_methods_56[] = { "__init__", "check_returncode", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.CompletedProcess";
    rt.short_name = "CompletedProcess";
    rt.method_names = py_methods_56;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.CompletedProcess.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.CompletedProcess";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.CompletedProcess.check_returncode";
    rf.short_name = "check_returncode";
    rf.receiver_type = "asyncio.CompletedProcess";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.SubprocessError";
    rt.short_name = "SubprocessError";
    static const char* py_bases_57[] = { "subprocess.Exception", NULL };
    rt.embedded_types = py_bases_57;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_58[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.TimeoutExpired";
    rt.short_name = "TimeoutExpired";
    rt.method_names = py_methods_58;
    static const char* py_bases_59[] = { "subprocess.SubprocessError", NULL };
    rt.embedded_types = py_bases_59;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.TimeoutExpired.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.TimeoutExpired";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_60[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.CalledProcessError";
    rt.short_name = "CalledProcessError";
    rt.method_names = py_methods_60;
    static const char* py_bases_61[] = { "subprocess.SubprocessError", NULL };
    rt.embedded_types = py_bases_61;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.CalledProcessError.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.CalledProcessError";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_62[] = { "__init__", "poll", "wait", "communicate", "send_signal", "terminate", "kill", "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.Popen";
    rt.short_name = "Popen";
    rt.method_names = py_methods_62;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.Popen.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.Popen.poll";
    rf.short_name = "poll";
    rf.receiver_type = "asyncio.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.Popen.wait";
    rf.short_name = "wait";
    rf.receiver_type = "asyncio.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.Popen.communicate";
    rf.short_name = "communicate";
    rf.receiver_type = "asyncio.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.Popen.send_signal";
    rf.short_name = "send_signal";
    rf.receiver_type = "asyncio.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.Popen.terminate";
    rf.short_name = "terminate";
    rf.receiver_type = "asyncio.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.Popen.kill";
    rf.short_name = "kill";
    rf.receiver_type = "asyncio.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.Popen.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "asyncio.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.Popen.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "asyncio.Popen";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_63[] = { "__init__", "copy", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.STARTUPINFO";
    rt.short_name = "STARTUPINFO";
    rt.method_names = py_methods_63;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.STARTUPINFO.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.STARTUPINFO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.STARTUPINFO.copy";
    rf.short_name = "copy";
    rf.receiver_type = "asyncio.STARTUPINFO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.run";
    rf.short_name = "run";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.call";
    rf.short_name = "call";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.check_call";
    rf.short_name = "check_call";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.check_output";
    rf.short_name = "check_output";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.getstatusoutput";
    rf.short_name = "getstatusoutput";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.getoutput";
    rf.short_name = "getoutput";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.list2cmdline";
    rf.short_name = "list2cmdline";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.base_events ===== */
    static const char* py_methods_64[] = { "__init__", "close_clients", "abort_clients", "get_loop", "is_serving", "start_serving", "serve_forever", "sockets", "close", "wait_closed", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.base_events.Server";
    rt.short_name = "Server";
    rt.method_names = py_methods_64;
    static const char* py_bases_65[] = { "asyncio.base_events.AbstractServer", NULL };
    rt.embedded_types = py_bases_65;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.Server.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.base_events.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.Server.close_clients";
    rf.short_name = "close_clients";
    rf.receiver_type = "asyncio.base_events.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.Server.abort_clients";
    rf.short_name = "abort_clients";
    rf.receiver_type = "asyncio.base_events.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.Server.get_loop";
    rf.short_name = "get_loop";
    rf.receiver_type = "asyncio.base_events.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.Server.is_serving";
    rf.short_name = "is_serving";
    rf.receiver_type = "asyncio.base_events.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.Server.start_serving";
    rf.short_name = "start_serving";
    rf.receiver_type = "asyncio.base_events.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.Server.serve_forever";
    rf.short_name = "serve_forever";
    rf.receiver_type = "asyncio.base_events.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.Server.sockets";
    rf.short_name = "sockets";
    rf.receiver_type = "asyncio.base_events.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.Server.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.base_events.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.Server.wait_closed";
    rf.short_name = "wait_closed";
    rf.receiver_type = "asyncio.base_events.Server";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_66[] = { "run_forever", "run_until_complete", "stop", "is_running", "is_closed", "close", "shutdown_asyncgens", "call_soon", "call_later", "call_at", "time", "create_future", "create_task", "set_task_factory", "get_task_factory", "call_soon_threadsafe", "run_in_executor", "set_default_executor", "getaddrinfo", "getnameinfo", "create_connection", "create_server", "start_tls", "connect_accepted_socket", "sock_sendfile", "sendfile", "create_datagram_endpoint", "connect_read_pipe", "connect_write_pipe", "subprocess_shell", "subprocess_exec", "add_reader", "remove_reader", "add_writer", "remove_writer", "sock_recv", "sock_recv_into", "sock_sendall", "sock_connect", "sock_accept", "sock_recvfrom", "sock_recvfrom_into", "sock_sendto", "add_signal_handler", "remove_signal_handler", "set_exception_handler", "get_exception_handler", "default_exception_handler", "call_exception_handler", "get_debug", "set_debug", "shutdown_default_executor", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.base_events.BaseEventLoop";
    rt.short_name = "BaseEventLoop";
    rt.method_names = py_methods_66;
    static const char* py_bases_67[] = { "asyncio.base_events.AbstractEventLoop", NULL };
    rt.embedded_types = py_bases_67;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.run_forever";
    rf.short_name = "run_forever";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.run_until_complete";
    rf.short_name = "run_until_complete";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.stop";
    rf.short_name = "stop";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.is_running";
    rf.short_name = "is_running";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.is_closed";
    rf.short_name = "is_closed";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.shutdown_asyncgens";
    rf.short_name = "shutdown_asyncgens";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.call_soon";
    rf.short_name = "call_soon";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.call_later";
    rf.short_name = "call_later";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.call_at";
    rf.short_name = "call_at";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.time";
    rf.short_name = "time";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.create_future";
    rf.short_name = "create_future";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.create_task";
    rf.short_name = "create_task";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.set_task_factory";
    rf.short_name = "set_task_factory";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.get_task_factory";
    rf.short_name = "get_task_factory";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.call_soon_threadsafe";
    rf.short_name = "call_soon_threadsafe";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.run_in_executor";
    rf.short_name = "run_in_executor";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.set_default_executor";
    rf.short_name = "set_default_executor";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.getaddrinfo";
    rf.short_name = "getaddrinfo";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.getnameinfo";
    rf.short_name = "getnameinfo";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.create_connection";
    rf.short_name = "create_connection";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.create_server";
    rf.short_name = "create_server";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.start_tls";
    rf.short_name = "start_tls";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.connect_accepted_socket";
    rf.short_name = "connect_accepted_socket";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.sock_sendfile";
    rf.short_name = "sock_sendfile";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.sendfile";
    rf.short_name = "sendfile";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.create_datagram_endpoint";
    rf.short_name = "create_datagram_endpoint";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.connect_read_pipe";
    rf.short_name = "connect_read_pipe";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.connect_write_pipe";
    rf.short_name = "connect_write_pipe";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.subprocess_shell";
    rf.short_name = "subprocess_shell";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.subprocess_exec";
    rf.short_name = "subprocess_exec";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.add_reader";
    rf.short_name = "add_reader";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.remove_reader";
    rf.short_name = "remove_reader";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.add_writer";
    rf.short_name = "add_writer";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.remove_writer";
    rf.short_name = "remove_writer";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.sock_recv";
    rf.short_name = "sock_recv";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.sock_recv_into";
    rf.short_name = "sock_recv_into";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.sock_sendall";
    rf.short_name = "sock_sendall";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.sock_connect";
    rf.short_name = "sock_connect";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.sock_accept";
    rf.short_name = "sock_accept";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.sock_recvfrom";
    rf.short_name = "sock_recvfrom";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.sock_recvfrom_into";
    rf.short_name = "sock_recvfrom_into";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.sock_sendto";
    rf.short_name = "sock_sendto";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.add_signal_handler";
    rf.short_name = "add_signal_handler";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.remove_signal_handler";
    rf.short_name = "remove_signal_handler";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.set_exception_handler";
    rf.short_name = "set_exception_handler";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.get_exception_handler";
    rf.short_name = "get_exception_handler";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.default_exception_handler";
    rf.short_name = "default_exception_handler";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.call_exception_handler";
    rf.short_name = "call_exception_handler";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.get_debug";
    rf.short_name = "get_debug";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.set_debug";
    rf.short_name = "set_debug";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_events.BaseEventLoop.shutdown_default_executor";
    rf.short_name = "shutdown_default_executor";
    rf.receiver_type = "asyncio.base_events.BaseEventLoop";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.base_futures ===== */
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_futures.isfuture";
    rf.short_name = "isfuture";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.base_subprocess ===== */
    static const char* py_methods_68[] = { "__init__", "get_pid", "get_pipe_transport", "send_signal", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.base_subprocess.BaseSubprocessTransport";
    rt.short_name = "BaseSubprocessTransport";
    rt.method_names = py_methods_68;
    static const char* py_bases_69[] = { "transports.SubprocessTransport", NULL };
    rt.embedded_types = py_bases_69;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_subprocess.BaseSubprocessTransport.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.base_subprocess.BaseSubprocessTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_subprocess.BaseSubprocessTransport.get_pid";
    rf.short_name = "get_pid";
    rf.receiver_type = "asyncio.base_subprocess.BaseSubprocessTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_subprocess.BaseSubprocessTransport.get_pipe_transport";
    rf.short_name = "get_pipe_transport";
    rf.receiver_type = "asyncio.base_subprocess.BaseSubprocessTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_subprocess.BaseSubprocessTransport.send_signal";
    rf.short_name = "send_signal";
    rf.receiver_type = "asyncio.base_subprocess.BaseSubprocessTransport";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_70[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.base_subprocess.WriteSubprocessPipeProto";
    rt.short_name = "WriteSubprocessPipeProto";
    rt.method_names = py_methods_70;
    static const char* py_bases_71[] = { "protocols.BaseProtocol", NULL };
    rt.embedded_types = py_bases_71;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.base_subprocess.WriteSubprocessPipeProto.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.base_subprocess.WriteSubprocessPipeProto";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.base_subprocess.ReadSubprocessPipeProto";
    rt.short_name = "ReadSubprocessPipeProto";
    static const char* py_bases_72[] = { "asyncio.base_subprocess.WriteSubprocessPipeProto", "protocols.Protocol", NULL };
    rt.embedded_types = py_bases_72;
    cbm_registry_add_type(reg, rt);

    /* ===== module: asyncio.constants ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.constants._SendfileMode";
    rt.short_name = "_SendfileMode";
    static const char* py_bases_73[] = { "enum.Enum", NULL };
    rt.embedded_types = py_bases_73;
    cbm_registry_add_type(reg, rt);

    /* ===== module: asyncio.coroutines ===== */
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.coroutines.coroutine";
    rf.short_name = "coroutine";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.coroutines.iscoroutine";
    rf.short_name = "iscoroutine";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.coroutines.iscoroutinefunction";
    rf.short_name = "iscoroutinefunction";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.events ===== */
    static const char* py_methods_74[] = { "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.events._TaskFactory";
    rt.short_name = "_TaskFactory";
    rt.method_names = py_methods_74;
    static const char* py_bases_75[] = { "asyncio.events.Protocol", NULL };
    rt.embedded_types = py_bases_75;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events._TaskFactory.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "asyncio.events._TaskFactory";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_76[] = { "__init__", "cancel", "cancelled", "get_context", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.events.Handle";
    rt.short_name = "Handle";
    rt.method_names = py_methods_76;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.Handle.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.events.Handle";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.Handle.cancel";
    rf.short_name = "cancel";
    rf.receiver_type = "asyncio.events.Handle";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.Handle.cancelled";
    rf.short_name = "cancelled";
    rf.receiver_type = "asyncio.events.Handle";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.Handle.get_context";
    rf.short_name = "get_context";
    rf.receiver_type = "asyncio.events.Handle";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_77[] = { "__init__", "when", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.events.TimerHandle";
    rt.short_name = "TimerHandle";
    rt.method_names = py_methods_77;
    static const char* py_bases_78[] = { "asyncio.events.Handle", NULL };
    rt.embedded_types = py_bases_78;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.TimerHandle.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.events.TimerHandle";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.TimerHandle.when";
    rf.short_name = "when";
    rf.receiver_type = "asyncio.events.TimerHandle";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_79[] = { "close", "close_clients", "abort_clients", "get_loop", "is_serving", "start_serving", "serve_forever", "wait_closed", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.events.AbstractServer";
    rt.short_name = "AbstractServer";
    rt.method_names = py_methods_79;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractServer.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.events.AbstractServer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractServer.close_clients";
    rf.short_name = "close_clients";
    rf.receiver_type = "asyncio.events.AbstractServer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractServer.abort_clients";
    rf.short_name = "abort_clients";
    rf.receiver_type = "asyncio.events.AbstractServer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractServer.get_loop";
    rf.short_name = "get_loop";
    rf.receiver_type = "asyncio.events.AbstractServer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractServer.is_serving";
    rf.short_name = "is_serving";
    rf.receiver_type = "asyncio.events.AbstractServer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractServer.start_serving";
    rf.short_name = "start_serving";
    rf.receiver_type = "asyncio.events.AbstractServer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractServer.serve_forever";
    rf.short_name = "serve_forever";
    rf.receiver_type = "asyncio.events.AbstractServer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractServer.wait_closed";
    rf.short_name = "wait_closed";
    rf.receiver_type = "asyncio.events.AbstractServer";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_80[] = { "run_forever", "run_until_complete", "stop", "is_running", "is_closed", "close", "shutdown_asyncgens", "call_soon", "call_later", "call_at", "time", "create_future", "create_task", "set_task_factory", "get_task_factory", "call_soon_threadsafe", "run_in_executor", "set_default_executor", "getaddrinfo", "getnameinfo", "create_connection", "create_server", "start_tls", "create_unix_server", "connect_accepted_socket", "create_unix_connection", "sock_sendfile", "sendfile", "create_datagram_endpoint", "connect_read_pipe", "connect_write_pipe", "subprocess_shell", "subprocess_exec", "add_reader", "remove_reader", "add_writer", "remove_writer", "sock_recv", "sock_recv_into", "sock_sendall", "sock_connect", "sock_accept", "sock_recvfrom", "sock_recvfrom_into", "sock_sendto", "add_signal_handler", "remove_signal_handler", "set_exception_handler", "get_exception_handler", "default_exception_handler", "call_exception_handler", "get_debug", "set_debug", "shutdown_default_executor", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.events.AbstractEventLoop";
    rt.short_name = "AbstractEventLoop";
    rt.method_names = py_methods_80;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.run_forever";
    rf.short_name = "run_forever";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.run_until_complete";
    rf.short_name = "run_until_complete";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.stop";
    rf.short_name = "stop";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.is_running";
    rf.short_name = "is_running";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.is_closed";
    rf.short_name = "is_closed";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.shutdown_asyncgens";
    rf.short_name = "shutdown_asyncgens";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.call_soon";
    rf.short_name = "call_soon";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.call_later";
    rf.short_name = "call_later";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.call_at";
    rf.short_name = "call_at";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.time";
    rf.short_name = "time";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.create_future";
    rf.short_name = "create_future";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.create_task";
    rf.short_name = "create_task";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.set_task_factory";
    rf.short_name = "set_task_factory";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.get_task_factory";
    rf.short_name = "get_task_factory";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.call_soon_threadsafe";
    rf.short_name = "call_soon_threadsafe";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.run_in_executor";
    rf.short_name = "run_in_executor";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.set_default_executor";
    rf.short_name = "set_default_executor";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.getaddrinfo";
    rf.short_name = "getaddrinfo";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.getnameinfo";
    rf.short_name = "getnameinfo";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.create_connection";
    rf.short_name = "create_connection";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.create_server";
    rf.short_name = "create_server";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.start_tls";
    rf.short_name = "start_tls";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.create_unix_server";
    rf.short_name = "create_unix_server";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.connect_accepted_socket";
    rf.short_name = "connect_accepted_socket";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.create_unix_connection";
    rf.short_name = "create_unix_connection";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.sock_sendfile";
    rf.short_name = "sock_sendfile";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.sendfile";
    rf.short_name = "sendfile";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.create_datagram_endpoint";
    rf.short_name = "create_datagram_endpoint";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.connect_read_pipe";
    rf.short_name = "connect_read_pipe";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.connect_write_pipe";
    rf.short_name = "connect_write_pipe";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.subprocess_shell";
    rf.short_name = "subprocess_shell";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.subprocess_exec";
    rf.short_name = "subprocess_exec";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.add_reader";
    rf.short_name = "add_reader";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.remove_reader";
    rf.short_name = "remove_reader";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.add_writer";
    rf.short_name = "add_writer";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.remove_writer";
    rf.short_name = "remove_writer";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.sock_recv";
    rf.short_name = "sock_recv";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.sock_recv_into";
    rf.short_name = "sock_recv_into";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.sock_sendall";
    rf.short_name = "sock_sendall";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.sock_connect";
    rf.short_name = "sock_connect";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.sock_accept";
    rf.short_name = "sock_accept";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.sock_recvfrom";
    rf.short_name = "sock_recvfrom";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.sock_recvfrom_into";
    rf.short_name = "sock_recvfrom_into";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.sock_sendto";
    rf.short_name = "sock_sendto";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.add_signal_handler";
    rf.short_name = "add_signal_handler";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.remove_signal_handler";
    rf.short_name = "remove_signal_handler";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.set_exception_handler";
    rf.short_name = "set_exception_handler";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.get_exception_handler";
    rf.short_name = "get_exception_handler";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.default_exception_handler";
    rf.short_name = "default_exception_handler";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.call_exception_handler";
    rf.short_name = "call_exception_handler";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.get_debug";
    rf.short_name = "get_debug";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.set_debug";
    rf.short_name = "set_debug";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.AbstractEventLoop.shutdown_default_executor";
    rf.short_name = "shutdown_default_executor";
    rf.receiver_type = "asyncio.events.AbstractEventLoop";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_81[] = { "get_event_loop", "set_event_loop", "new_event_loop", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.events._AbstractEventLoopPolicy";
    rt.short_name = "_AbstractEventLoopPolicy";
    rt.method_names = py_methods_81;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events._AbstractEventLoopPolicy.get_event_loop";
    rf.short_name = "get_event_loop";
    rf.receiver_type = "asyncio.events._AbstractEventLoopPolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events._AbstractEventLoopPolicy.set_event_loop";
    rf.short_name = "set_event_loop";
    rf.receiver_type = "asyncio.events._AbstractEventLoopPolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events._AbstractEventLoopPolicy.new_event_loop";
    rf.short_name = "new_event_loop";
    rf.receiver_type = "asyncio.events._AbstractEventLoopPolicy";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_82[] = { "get_event_loop", "set_event_loop", "new_event_loop", "get_child_watcher", "set_child_watcher", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.events._AbstractEventLoopPolicy";
    rt.short_name = "_AbstractEventLoopPolicy";
    rt.method_names = py_methods_82;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events._AbstractEventLoopPolicy.get_event_loop";
    rf.short_name = "get_event_loop";
    rf.receiver_type = "asyncio.events._AbstractEventLoopPolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events._AbstractEventLoopPolicy.set_event_loop";
    rf.short_name = "set_event_loop";
    rf.receiver_type = "asyncio.events._AbstractEventLoopPolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events._AbstractEventLoopPolicy.new_event_loop";
    rf.short_name = "new_event_loop";
    rf.receiver_type = "asyncio.events._AbstractEventLoopPolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events._AbstractEventLoopPolicy.get_child_watcher";
    rf.short_name = "get_child_watcher";
    rf.receiver_type = "asyncio.events._AbstractEventLoopPolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events._AbstractEventLoopPolicy.set_child_watcher";
    rf.short_name = "set_child_watcher";
    rf.receiver_type = "asyncio.events._AbstractEventLoopPolicy";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_83[] = { "get_event_loop", "set_event_loop", "new_event_loop", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.events._BaseDefaultEventLoopPolicy";
    rt.short_name = "_BaseDefaultEventLoopPolicy";
    rt.method_names = py_methods_83;
    static const char* py_bases_84[] = { "asyncio.events._AbstractEventLoopPolicy", NULL };
    rt.embedded_types = py_bases_84;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events._BaseDefaultEventLoopPolicy.get_event_loop";
    rf.short_name = "get_event_loop";
    rf.receiver_type = "asyncio.events._BaseDefaultEventLoopPolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events._BaseDefaultEventLoopPolicy.set_event_loop";
    rf.short_name = "set_event_loop";
    rf.receiver_type = "asyncio.events._BaseDefaultEventLoopPolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events._BaseDefaultEventLoopPolicy.new_event_loop";
    rf.short_name = "new_event_loop";
    rf.receiver_type = "asyncio.events._BaseDefaultEventLoopPolicy";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_85[] = { "get_event_loop", "set_event_loop", "new_event_loop", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.events.BaseDefaultEventLoopPolicy";
    rt.short_name = "BaseDefaultEventLoopPolicy";
    rt.method_names = py_methods_85;
    static const char* py_bases_86[] = { "asyncio.events._AbstractEventLoopPolicy", NULL };
    rt.embedded_types = py_bases_86;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.BaseDefaultEventLoopPolicy.get_event_loop";
    rf.short_name = "get_event_loop";
    rf.receiver_type = "asyncio.events.BaseDefaultEventLoopPolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.BaseDefaultEventLoopPolicy.set_event_loop";
    rf.short_name = "set_event_loop";
    rf.receiver_type = "asyncio.events.BaseDefaultEventLoopPolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.BaseDefaultEventLoopPolicy.new_event_loop";
    rf.short_name = "new_event_loop";
    rf.receiver_type = "asyncio.events.BaseDefaultEventLoopPolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.get_event_loop_policy";
    rf.short_name = "get_event_loop_policy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.set_event_loop_policy";
    rf.short_name = "set_event_loop_policy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.set_event_loop";
    rf.short_name = "set_event_loop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.new_event_loop";
    rf.short_name = "new_event_loop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.get_child_watcher";
    rf.short_name = "get_child_watcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.events.set_child_watcher";
    rf.short_name = "set_child_watcher";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.exceptions ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.exceptions.CancelledError";
    rt.short_name = "CancelledError";
    static const char* py_bases_87[] = { "asyncio.exceptions.BaseException", NULL };
    rt.embedded_types = py_bases_87;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.exceptions.TimeoutError";
    rt.short_name = "TimeoutError";
    static const char* py_bases_88[] = { "asyncio.exceptions.Exception", NULL };
    rt.embedded_types = py_bases_88;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.exceptions.InvalidStateError";
    rt.short_name = "InvalidStateError";
    static const char* py_bases_89[] = { "asyncio.exceptions.Exception", NULL };
    rt.embedded_types = py_bases_89;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.exceptions.SendfileNotAvailableError";
    rt.short_name = "SendfileNotAvailableError";
    static const char* py_bases_90[] = { "asyncio.exceptions.RuntimeError", NULL };
    rt.embedded_types = py_bases_90;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_91[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.exceptions.IncompleteReadError";
    rt.short_name = "IncompleteReadError";
    rt.method_names = py_methods_91;
    static const char* py_bases_92[] = { "asyncio.exceptions.EOFError", NULL };
    rt.embedded_types = py_bases_92;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.exceptions.IncompleteReadError.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.exceptions.IncompleteReadError";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_93[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.exceptions.LimitOverrunError";
    rt.short_name = "LimitOverrunError";
    rt.method_names = py_methods_93;
    static const char* py_bases_94[] = { "asyncio.exceptions.Exception", NULL };
    rt.embedded_types = py_bases_94;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.exceptions.LimitOverrunError.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.exceptions.LimitOverrunError";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.exceptions.BrokenBarrierError";
    rt.short_name = "BrokenBarrierError";
    static const char* py_bases_95[] = { "asyncio.exceptions.RuntimeError", NULL };
    rt.embedded_types = py_bases_95;
    cbm_registry_add_type(reg, rt);

    /* ===== module: asyncio.format_helpers ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.format_helpers._HasWrapper";
    rt.short_name = "_HasWrapper";
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.format_helpers.extract_stack";
    rf.short_name = "extract_stack";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.futures ===== */
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.futures.wrap_future";
    rf.short_name = "wrap_future";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.graph ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.graph.FrameCallGraphEntry";
    rt.short_name = "FrameCallGraphEntry";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.graph.FutureCallGraph";
    rt.short_name = "FutureCallGraph";
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.graph.capture_call_graph";
    rf.short_name = "capture_call_graph";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.graph.format_call_graph";
    rf.short_name = "format_call_graph";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.graph.print_call_graph";
    rf.short_name = "print_call_graph";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.locks ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.locks._ContextManagerMixin";
    rt.short_name = "_ContextManagerMixin";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_96[] = { "__init__", "locked", "acquire", "release", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.locks.Lock";
    rt.short_name = "Lock";
    rt.method_names = py_methods_96;
    static const char* py_bases_97[] = { "asyncio.locks._ContextManagerMixin", "asyncio.locks._LoopBoundMixin", NULL };
    rt.embedded_types = py_bases_97;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Lock.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.locks.Lock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Lock.locked";
    rf.short_name = "locked";
    rf.receiver_type = "asyncio.locks.Lock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Lock.acquire";
    rf.short_name = "acquire";
    rf.receiver_type = "asyncio.locks.Lock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Lock.release";
    rf.short_name = "release";
    rf.receiver_type = "asyncio.locks.Lock";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_98[] = { "__init__", "is_set", "set", "clear", "wait", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.locks.Event";
    rt.short_name = "Event";
    rt.method_names = py_methods_98;
    static const char* py_bases_99[] = { "asyncio.locks._LoopBoundMixin", NULL };
    rt.embedded_types = py_bases_99;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Event.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.locks.Event";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Event.is_set";
    rf.short_name = "is_set";
    rf.receiver_type = "asyncio.locks.Event";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Event.set";
    rf.short_name = "set";
    rf.receiver_type = "asyncio.locks.Event";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Event.clear";
    rf.short_name = "clear";
    rf.receiver_type = "asyncio.locks.Event";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Event.wait";
    rf.short_name = "wait";
    rf.receiver_type = "asyncio.locks.Event";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_100[] = { "__init__", "locked", "acquire", "release", "wait", "wait_for", "notify", "notify_all", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.locks.Condition";
    rt.short_name = "Condition";
    rt.method_names = py_methods_100;
    static const char* py_bases_101[] = { "asyncio.locks._ContextManagerMixin", "asyncio.locks._LoopBoundMixin", NULL };
    rt.embedded_types = py_bases_101;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Condition.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.locks.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Condition.locked";
    rf.short_name = "locked";
    rf.receiver_type = "asyncio.locks.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Condition.acquire";
    rf.short_name = "acquire";
    rf.receiver_type = "asyncio.locks.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Condition.release";
    rf.short_name = "release";
    rf.receiver_type = "asyncio.locks.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Condition.wait";
    rf.short_name = "wait";
    rf.receiver_type = "asyncio.locks.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Condition.wait_for";
    rf.short_name = "wait_for";
    rf.receiver_type = "asyncio.locks.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Condition.notify";
    rf.short_name = "notify";
    rf.receiver_type = "asyncio.locks.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Condition.notify_all";
    rf.short_name = "notify_all";
    rf.receiver_type = "asyncio.locks.Condition";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_102[] = { "__init__", "locked", "acquire", "release", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.locks.Semaphore";
    rt.short_name = "Semaphore";
    rt.method_names = py_methods_102;
    static const char* py_bases_103[] = { "asyncio.locks._ContextManagerMixin", "asyncio.locks._LoopBoundMixin", NULL };
    rt.embedded_types = py_bases_103;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Semaphore.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.locks.Semaphore";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Semaphore.locked";
    rf.short_name = "locked";
    rf.receiver_type = "asyncio.locks.Semaphore";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Semaphore.acquire";
    rf.short_name = "acquire";
    rf.receiver_type = "asyncio.locks.Semaphore";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Semaphore.release";
    rf.short_name = "release";
    rf.receiver_type = "asyncio.locks.Semaphore";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.locks.BoundedSemaphore";
    rt.short_name = "BoundedSemaphore";
    static const char* py_bases_104[] = { "asyncio.locks.Semaphore", NULL };
    rt.embedded_types = py_bases_104;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.locks._BarrierState";
    rt.short_name = "_BarrierState";
    static const char* py_bases_105[] = { "enum.Enum", NULL };
    rt.embedded_types = py_bases_105;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_106[] = { "__init__", "wait", "abort", "reset", "parties", "n_waiting", "broken", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.locks.Barrier";
    rt.short_name = "Barrier";
    rt.method_names = py_methods_106;
    static const char* py_bases_107[] = { "asyncio.locks._LoopBoundMixin", NULL };
    rt.embedded_types = py_bases_107;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Barrier.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.locks.Barrier";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Barrier.wait";
    rf.short_name = "wait";
    rf.receiver_type = "asyncio.locks.Barrier";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Barrier.abort";
    rf.short_name = "abort";
    rf.receiver_type = "asyncio.locks.Barrier";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Barrier.reset";
    rf.short_name = "reset";
    rf.receiver_type = "asyncio.locks.Barrier";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Barrier.parties";
    rf.short_name = "parties";
    rf.receiver_type = "asyncio.locks.Barrier";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Barrier.n_waiting";
    rf.short_name = "n_waiting";
    rf.receiver_type = "asyncio.locks.Barrier";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.locks.Barrier.broken";
    rf.short_name = "broken";
    rf.receiver_type = "asyncio.locks.Barrier";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.mixins ===== */
    static const char* py_methods_108[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.mixins._LoopBoundMixin";
    rt.short_name = "_LoopBoundMixin";
    rt.method_names = py_methods_108;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.mixins._LoopBoundMixin.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.mixins._LoopBoundMixin";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.proactor_events ===== */
    static const char* py_methods_109[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.proactor_events._ProactorBasePipeTransport";
    rt.short_name = "_ProactorBasePipeTransport";
    rt.method_names = py_methods_109;
    static const char* py_bases_110[] = { "transports._FlowControlMixin", "transports.BaseTransport", NULL };
    rt.embedded_types = py_bases_110;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.proactor_events._ProactorBasePipeTransport.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.proactor_events._ProactorBasePipeTransport";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_111[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.proactor_events._ProactorReadPipeTransport";
    rt.short_name = "_ProactorReadPipeTransport";
    rt.method_names = py_methods_111;
    static const char* py_bases_112[] = { "asyncio.proactor_events._ProactorBasePipeTransport", "transports.ReadTransport", NULL };
    rt.embedded_types = py_bases_112;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.proactor_events._ProactorReadPipeTransport.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.proactor_events._ProactorReadPipeTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.proactor_events._ProactorBaseWritePipeTransport";
    rt.short_name = "_ProactorBaseWritePipeTransport";
    static const char* py_bases_113[] = { "asyncio.proactor_events._ProactorBasePipeTransport", "transports.WriteTransport", NULL };
    rt.embedded_types = py_bases_113;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.proactor_events._ProactorWritePipeTransport";
    rt.short_name = "_ProactorWritePipeTransport";
    static const char* py_bases_114[] = { "asyncio.proactor_events._ProactorBaseWritePipeTransport", NULL };
    rt.embedded_types = py_bases_114;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.proactor_events._ProactorDuplexPipeTransport";
    rt.short_name = "_ProactorDuplexPipeTransport";
    static const char* py_bases_115[] = { "asyncio.proactor_events._ProactorReadPipeTransport", "asyncio.proactor_events._ProactorBaseWritePipeTransport", "transports.Transport", NULL };
    rt.embedded_types = py_bases_115;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_116[] = { "__init__", "can_write_eof", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.proactor_events._ProactorSocketTransport";
    rt.short_name = "_ProactorSocketTransport";
    rt.method_names = py_methods_116;
    static const char* py_bases_117[] = { "asyncio.proactor_events._ProactorReadPipeTransport", "asyncio.proactor_events._ProactorBaseWritePipeTransport", "transports.Transport", NULL };
    rt.embedded_types = py_bases_117;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.proactor_events._ProactorSocketTransport.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.proactor_events._ProactorSocketTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.proactor_events._ProactorSocketTransport.can_write_eof";
    rf.short_name = "can_write_eof";
    rf.receiver_type = "asyncio.proactor_events._ProactorSocketTransport";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_118[] = { "__init__", "sock_recv", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.proactor_events.BaseProactorEventLoop";
    rt.short_name = "BaseProactorEventLoop";
    rt.method_names = py_methods_118;
    static const char* py_bases_119[] = { "base_events.BaseEventLoop", NULL };
    rt.embedded_types = py_bases_119;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.proactor_events.BaseProactorEventLoop.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.proactor_events.BaseProactorEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.proactor_events.BaseProactorEventLoop.sock_recv";
    rf.short_name = "sock_recv";
    rf.receiver_type = "asyncio.proactor_events.BaseProactorEventLoop";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.protocols ===== */
    static const char* py_methods_120[] = { "connection_made", "connection_lost", "pause_writing", "resume_writing", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.protocols.BaseProtocol";
    rt.short_name = "BaseProtocol";
    rt.method_names = py_methods_120;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.protocols.BaseProtocol.connection_made";
    rf.short_name = "connection_made";
    rf.receiver_type = "asyncio.protocols.BaseProtocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.protocols.BaseProtocol.connection_lost";
    rf.short_name = "connection_lost";
    rf.receiver_type = "asyncio.protocols.BaseProtocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.protocols.BaseProtocol.pause_writing";
    rf.short_name = "pause_writing";
    rf.receiver_type = "asyncio.protocols.BaseProtocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.protocols.BaseProtocol.resume_writing";
    rf.short_name = "resume_writing";
    rf.receiver_type = "asyncio.protocols.BaseProtocol";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_121[] = { "data_received", "eof_received", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.protocols.Protocol";
    rt.short_name = "Protocol";
    rt.method_names = py_methods_121;
    static const char* py_bases_122[] = { "asyncio.protocols.BaseProtocol", NULL };
    rt.embedded_types = py_bases_122;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.protocols.Protocol.data_received";
    rf.short_name = "data_received";
    rf.receiver_type = "asyncio.protocols.Protocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.protocols.Protocol.eof_received";
    rf.short_name = "eof_received";
    rf.receiver_type = "asyncio.protocols.Protocol";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_123[] = { "get_buffer", "buffer_updated", "eof_received", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.protocols.BufferedProtocol";
    rt.short_name = "BufferedProtocol";
    rt.method_names = py_methods_123;
    static const char* py_bases_124[] = { "asyncio.protocols.BaseProtocol", NULL };
    rt.embedded_types = py_bases_124;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.protocols.BufferedProtocol.get_buffer";
    rf.short_name = "get_buffer";
    rf.receiver_type = "asyncio.protocols.BufferedProtocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.protocols.BufferedProtocol.buffer_updated";
    rf.short_name = "buffer_updated";
    rf.receiver_type = "asyncio.protocols.BufferedProtocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.protocols.BufferedProtocol.eof_received";
    rf.short_name = "eof_received";
    rf.receiver_type = "asyncio.protocols.BufferedProtocol";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_125[] = { "connection_made", "datagram_received", "error_received", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.protocols.DatagramProtocol";
    rt.short_name = "DatagramProtocol";
    rt.method_names = py_methods_125;
    static const char* py_bases_126[] = { "asyncio.protocols.BaseProtocol", NULL };
    rt.embedded_types = py_bases_126;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.protocols.DatagramProtocol.connection_made";
    rf.short_name = "connection_made";
    rf.receiver_type = "asyncio.protocols.DatagramProtocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.protocols.DatagramProtocol.datagram_received";
    rf.short_name = "datagram_received";
    rf.receiver_type = "asyncio.protocols.DatagramProtocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.protocols.DatagramProtocol.error_received";
    rf.short_name = "error_received";
    rf.receiver_type = "asyncio.protocols.DatagramProtocol";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_127[] = { "pipe_data_received", "pipe_connection_lost", "process_exited", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.protocols.SubprocessProtocol";
    rt.short_name = "SubprocessProtocol";
    rt.method_names = py_methods_127;
    static const char* py_bases_128[] = { "asyncio.protocols.BaseProtocol", NULL };
    rt.embedded_types = py_bases_128;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.protocols.SubprocessProtocol.pipe_data_received";
    rf.short_name = "pipe_data_received";
    rf.receiver_type = "asyncio.protocols.SubprocessProtocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.protocols.SubprocessProtocol.pipe_connection_lost";
    rf.short_name = "pipe_connection_lost";
    rf.receiver_type = "asyncio.protocols.SubprocessProtocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.protocols.SubprocessProtocol.process_exited";
    rf.short_name = "process_exited";
    rf.receiver_type = "asyncio.protocols.SubprocessProtocol";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.queues ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.queues.QueueEmpty";
    rt.short_name = "QueueEmpty";
    static const char* py_bases_129[] = { "asyncio.queues.Exception", NULL };
    rt.embedded_types = py_bases_129;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.queues.QueueFull";
    rt.short_name = "QueueFull";
    static const char* py_bases_130[] = { "asyncio.queues.Exception", NULL };
    rt.embedded_types = py_bases_130;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.queues.QueueShutDown";
    rt.short_name = "QueueShutDown";
    static const char* py_bases_131[] = { "asyncio.queues.Exception", NULL };
    rt.embedded_types = py_bases_131;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_132[] = { "__init__", "qsize", "maxsize", "empty", "full", "put", "put_nowait", "get", "get_nowait", "join", "task_done", "shutdown", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.queues.Queue";
    rt.short_name = "Queue";
    rt.method_names = py_methods_132;
    static const char* py_bases_133[] = { "asyncio.queues._LoopBoundMixin", NULL };
    rt.embedded_types = py_bases_133;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.queues.Queue.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.queues.Queue.qsize";
    rf.short_name = "qsize";
    rf.receiver_type = "asyncio.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.queues.Queue.maxsize";
    rf.short_name = "maxsize";
    rf.receiver_type = "asyncio.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.queues.Queue.empty";
    rf.short_name = "empty";
    rf.receiver_type = "asyncio.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.queues.Queue.full";
    rf.short_name = "full";
    rf.receiver_type = "asyncio.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.queues.Queue.put";
    rf.short_name = "put";
    rf.receiver_type = "asyncio.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.queues.Queue.put_nowait";
    rf.short_name = "put_nowait";
    rf.receiver_type = "asyncio.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.queues.Queue.get";
    rf.short_name = "get";
    rf.receiver_type = "asyncio.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.queues.Queue.get_nowait";
    rf.short_name = "get_nowait";
    rf.receiver_type = "asyncio.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.queues.Queue.join";
    rf.short_name = "join";
    rf.receiver_type = "asyncio.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.queues.Queue.task_done";
    rf.short_name = "task_done";
    rf.receiver_type = "asyncio.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.queues.Queue.shutdown";
    rf.short_name = "shutdown";
    rf.receiver_type = "asyncio.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.queues.PriorityQueue";
    rt.short_name = "PriorityQueue";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.queues.LifoQueue";
    rt.short_name = "LifoQueue";
    cbm_registry_add_type(reg, rt);

    /* ===== module: asyncio.runners ===== */
    static const char* py_methods_134[] = { "__init__", "__enter__", "__exit__", "close", "get_loop", "run", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.runners.Runner";
    rt.short_name = "Runner";
    rt.method_names = py_methods_134;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.runners.Runner.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.runners.Runner";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.runners.Runner.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "asyncio.runners.Runner";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.runners.Runner.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "asyncio.runners.Runner";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.runners.Runner.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.runners.Runner";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.runners.Runner.get_loop";
    rf.short_name = "get_loop";
    rf.receiver_type = "asyncio.runners.Runner";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.runners.Runner.run";
    rf.short_name = "run";
    rf.receiver_type = "asyncio.runners.Runner";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.runners.run";
    rf.short_name = "run";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.selector_events ===== */
    static const char* py_methods_135[] = { "__init__", "sock_recv", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.selector_events.BaseSelectorEventLoop";
    rt.short_name = "BaseSelectorEventLoop";
    rt.method_names = py_methods_135;
    static const char* py_bases_136[] = { "base_events.BaseEventLoop", NULL };
    rt.embedded_types = py_bases_136;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.selector_events.BaseSelectorEventLoop.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.selector_events.BaseSelectorEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.selector_events.BaseSelectorEventLoop.sock_recv";
    rf.short_name = "sock_recv";
    rf.receiver_type = "asyncio.selector_events.BaseSelectorEventLoop";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.sslproto ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.sslproto.SSLProtocolState";
    rt.short_name = "SSLProtocolState";
    static const char* py_bases_137[] = { "asyncio.sslproto.Enum", NULL };
    rt.embedded_types = py_bases_137;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.sslproto.AppProtocolState";
    rt.short_name = "AppProtocolState";
    static const char* py_bases_138[] = { "asyncio.sslproto.Enum", NULL };
    rt.embedded_types = py_bases_138;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_139[] = { "__init__", "context", "ssl_object", "need_ssldata", "wrapped", "do_handshake", "shutdown", "feed_eof", "feed_ssldata", "feed_appdata", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.sslproto._SSLPipe";
    rt.short_name = "_SSLPipe";
    rt.method_names = py_methods_139;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto._SSLPipe.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.sslproto._SSLPipe";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto._SSLPipe.context";
    rf.short_name = "context";
    rf.receiver_type = "asyncio.sslproto._SSLPipe";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto._SSLPipe.ssl_object";
    rf.short_name = "ssl_object";
    rf.receiver_type = "asyncio.sslproto._SSLPipe";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto._SSLPipe.need_ssldata";
    rf.short_name = "need_ssldata";
    rf.receiver_type = "asyncio.sslproto._SSLPipe";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto._SSLPipe.wrapped";
    rf.short_name = "wrapped";
    rf.receiver_type = "asyncio.sslproto._SSLPipe";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto._SSLPipe.do_handshake";
    rf.short_name = "do_handshake";
    rf.receiver_type = "asyncio.sslproto._SSLPipe";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto._SSLPipe.shutdown";
    rf.short_name = "shutdown";
    rf.receiver_type = "asyncio.sslproto._SSLPipe";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto._SSLPipe.feed_eof";
    rf.short_name = "feed_eof";
    rf.receiver_type = "asyncio.sslproto._SSLPipe";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto._SSLPipe.feed_ssldata";
    rf.short_name = "feed_ssldata";
    rf.receiver_type = "asyncio.sslproto._SSLPipe";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto._SSLPipe.feed_appdata";
    rf.short_name = "feed_appdata";
    rf.receiver_type = "asyncio.sslproto._SSLPipe";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_140[] = { "__init__", "get_extra_info", "write", "can_write_eof", "get_write_buffer_limits", "get_read_buffer_limits", "set_read_buffer_limits", "get_read_buffer_size", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.sslproto._SSLProtocolTransport";
    rt.short_name = "_SSLProtocolTransport";
    rt.method_names = py_methods_140;
    static const char* py_bases_141[] = { "transports._FlowControlMixin", "transports.Transport", NULL };
    rt.embedded_types = py_bases_141;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto._SSLProtocolTransport.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.sslproto._SSLProtocolTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto._SSLProtocolTransport.get_extra_info";
    rf.short_name = "get_extra_info";
    rf.receiver_type = "asyncio.sslproto._SSLProtocolTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto._SSLProtocolTransport.write";
    rf.short_name = "write";
    rf.receiver_type = "asyncio.sslproto._SSLProtocolTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto._SSLProtocolTransport.can_write_eof";
    rf.short_name = "can_write_eof";
    rf.receiver_type = "asyncio.sslproto._SSLProtocolTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto._SSLProtocolTransport.get_write_buffer_limits";
    rf.short_name = "get_write_buffer_limits";
    rf.receiver_type = "asyncio.sslproto._SSLProtocolTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto._SSLProtocolTransport.get_read_buffer_limits";
    rf.short_name = "get_read_buffer_limits";
    rf.receiver_type = "asyncio.sslproto._SSLProtocolTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto._SSLProtocolTransport.set_read_buffer_limits";
    rf.short_name = "set_read_buffer_limits";
    rf.receiver_type = "asyncio.sslproto._SSLProtocolTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto._SSLProtocolTransport.get_read_buffer_size";
    rf.short_name = "get_read_buffer_size";
    rf.receiver_type = "asyncio.sslproto._SSLProtocolTransport";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_142[] = { "__init__", "connection_lost", "eof_received", "_write_appdata", "_abort", "get_buffer", "_finalize", "_process_write_backlog", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.sslproto.SSLProtocol";
    rt.short_name = "SSLProtocol";
    rt.method_names = py_methods_142;
    static const char* py_bases_143[] = { "asyncio.sslproto._SSLProtocolBase", NULL };
    rt.embedded_types = py_bases_143;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto.SSLProtocol.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.sslproto.SSLProtocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto.SSLProtocol.connection_lost";
    rf.short_name = "connection_lost";
    rf.receiver_type = "asyncio.sslproto.SSLProtocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto.SSLProtocol.eof_received";
    rf.short_name = "eof_received";
    rf.receiver_type = "asyncio.sslproto.SSLProtocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto.SSLProtocol._write_appdata";
    rf.short_name = "_write_appdata";
    rf.receiver_type = "asyncio.sslproto.SSLProtocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto.SSLProtocol._abort";
    rf.short_name = "_abort";
    rf.receiver_type = "asyncio.sslproto.SSLProtocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto.SSLProtocol.get_buffer";
    rf.short_name = "get_buffer";
    rf.receiver_type = "asyncio.sslproto.SSLProtocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto.SSLProtocol._finalize";
    rf.short_name = "_finalize";
    rf.receiver_type = "asyncio.sslproto.SSLProtocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto.SSLProtocol._process_write_backlog";
    rf.short_name = "_process_write_backlog";
    rf.receiver_type = "asyncio.sslproto.SSLProtocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.sslproto.add_flowcontrol_defaults";
    rf.short_name = "add_flowcontrol_defaults";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.staggered ===== */
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.staggered.staggered_race";
    rf.short_name = "staggered_race";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.streams ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.streams._ReaduntilBuffer";
    rt.short_name = "_ReaduntilBuffer";
    static const char* py_bases_144[] = { "asyncio.streams.ReadableBuffer", "asyncio.streams.Sized", "asyncio.streams.Protocol", NULL };
    rt.embedded_types = py_bases_144;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_145[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.streams.FlowControlMixin";
    rt.short_name = "FlowControlMixin";
    rt.method_names = py_methods_145;
    static const char* py_bases_146[] = { "protocols.Protocol", NULL };
    rt.embedded_types = py_bases_146;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.FlowControlMixin.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.streams.FlowControlMixin";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_147[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.streams.StreamReaderProtocol";
    rt.short_name = "StreamReaderProtocol";
    rt.method_names = py_methods_147;
    static const char* py_bases_148[] = { "asyncio.streams.FlowControlMixin", "protocols.Protocol", NULL };
    rt.embedded_types = py_bases_148;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamReaderProtocol.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.streams.StreamReaderProtocol";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_149[] = { "__init__", "transport", "write", "writelines", "write_eof", "can_write_eof", "close", "is_closing", "wait_closed", "get_extra_info", "drain", "start_tls", "__del__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.streams.StreamWriter";
    rt.short_name = "StreamWriter";
    rt.method_names = py_methods_149;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamWriter.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.streams.StreamWriter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamWriter.transport";
    rf.short_name = "transport";
    rf.receiver_type = "asyncio.streams.StreamWriter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamWriter.write";
    rf.short_name = "write";
    rf.receiver_type = "asyncio.streams.StreamWriter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamWriter.writelines";
    rf.short_name = "writelines";
    rf.receiver_type = "asyncio.streams.StreamWriter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamWriter.write_eof";
    rf.short_name = "write_eof";
    rf.receiver_type = "asyncio.streams.StreamWriter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamWriter.can_write_eof";
    rf.short_name = "can_write_eof";
    rf.receiver_type = "asyncio.streams.StreamWriter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamWriter.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.streams.StreamWriter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamWriter.is_closing";
    rf.short_name = "is_closing";
    rf.receiver_type = "asyncio.streams.StreamWriter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamWriter.wait_closed";
    rf.short_name = "wait_closed";
    rf.receiver_type = "asyncio.streams.StreamWriter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamWriter.get_extra_info";
    rf.short_name = "get_extra_info";
    rf.receiver_type = "asyncio.streams.StreamWriter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamWriter.drain";
    rf.short_name = "drain";
    rf.receiver_type = "asyncio.streams.StreamWriter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamWriter.start_tls";
    rf.short_name = "start_tls";
    rf.receiver_type = "asyncio.streams.StreamWriter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamWriter.__del__";
    rf.short_name = "__del__";
    rf.receiver_type = "asyncio.streams.StreamWriter";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_150[] = { "__init__", "exception", "set_exception", "set_transport", "feed_eof", "at_eof", "feed_data", "readline", "readuntil", "read", "readexactly", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.streams.StreamReader";
    rt.short_name = "StreamReader";
    rt.method_names = py_methods_150;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamReader.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.streams.StreamReader";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamReader.exception";
    rf.short_name = "exception";
    rf.receiver_type = "asyncio.streams.StreamReader";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamReader.set_exception";
    rf.short_name = "set_exception";
    rf.receiver_type = "asyncio.streams.StreamReader";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamReader.set_transport";
    rf.short_name = "set_transport";
    rf.receiver_type = "asyncio.streams.StreamReader";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamReader.feed_eof";
    rf.short_name = "feed_eof";
    rf.receiver_type = "asyncio.streams.StreamReader";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamReader.at_eof";
    rf.short_name = "at_eof";
    rf.receiver_type = "asyncio.streams.StreamReader";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamReader.feed_data";
    rf.short_name = "feed_data";
    rf.receiver_type = "asyncio.streams.StreamReader";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamReader.readline";
    rf.short_name = "readline";
    rf.receiver_type = "asyncio.streams.StreamReader";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamReader.readuntil";
    rf.short_name = "readuntil";
    rf.receiver_type = "asyncio.streams.StreamReader";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamReader.read";
    rf.short_name = "read";
    rf.receiver_type = "asyncio.streams.StreamReader";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.StreamReader.readexactly";
    rf.short_name = "readexactly";
    rf.receiver_type = "asyncio.streams.StreamReader";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.open_connection";
    rf.short_name = "open_connection";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.start_server";
    rf.short_name = "start_server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.open_unix_connection";
    rf.short_name = "open_unix_connection";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.streams.start_unix_server";
    rf.short_name = "start_unix_server";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.subprocess ===== */
    static const char* py_methods_151[] = { "__init__", "pipe_data_received", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.subprocess.SubprocessStreamProtocol";
    rt.short_name = "SubprocessStreamProtocol";
    rt.method_names = py_methods_151;
    static const char* py_bases_152[] = { "streams.FlowControlMixin", "protocols.SubprocessProtocol", NULL };
    rt.embedded_types = py_bases_152;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.subprocess.SubprocessStreamProtocol.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.subprocess.SubprocessStreamProtocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.subprocess.SubprocessStreamProtocol.pipe_data_received";
    rf.short_name = "pipe_data_received";
    rf.receiver_type = "asyncio.subprocess.SubprocessStreamProtocol";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_153[] = { "__init__", "returncode", "wait", "send_signal", "terminate", "kill", "communicate", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.subprocess.Process";
    rt.short_name = "Process";
    rt.method_names = py_methods_153;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.subprocess.Process.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.subprocess.Process";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.subprocess.Process.returncode";
    rf.short_name = "returncode";
    rf.receiver_type = "asyncio.subprocess.Process";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.subprocess.Process.wait";
    rf.short_name = "wait";
    rf.receiver_type = "asyncio.subprocess.Process";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.subprocess.Process.send_signal";
    rf.short_name = "send_signal";
    rf.receiver_type = "asyncio.subprocess.Process";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.subprocess.Process.terminate";
    rf.short_name = "terminate";
    rf.receiver_type = "asyncio.subprocess.Process";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.subprocess.Process.kill";
    rf.short_name = "kill";
    rf.receiver_type = "asyncio.subprocess.Process";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.subprocess.Process.communicate";
    rf.short_name = "communicate";
    rf.receiver_type = "asyncio.subprocess.Process";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.subprocess.create_subprocess_shell";
    rf.short_name = "create_subprocess_shell";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.subprocess.create_subprocess_exec";
    rf.short_name = "create_subprocess_exec";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.taskgroups ===== */
    static const char* py_methods_154[] = { "create_task", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.taskgroups.TaskGroup";
    rt.short_name = "TaskGroup";
    rt.method_names = py_methods_154;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.taskgroups.TaskGroup.create_task";
    rf.short_name = "create_task";
    rf.receiver_type = "asyncio.taskgroups.TaskGroup";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.tasks ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.tasks._SyncAndAsyncIterator";
    rt.short_name = "_SyncAndAsyncIterator";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_155[] = { "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.tasks._CustomTaskConstructor";
    rt.short_name = "_CustomTaskConstructor";
    rt.method_names = py_methods_155;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tasks._CustomTaskConstructor.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "asyncio.tasks._CustomTaskConstructor";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_156[] = { "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.tasks._EagerTaskFactoryType";
    rt.short_name = "_EagerTaskFactoryType";
    rt.method_names = py_methods_156;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tasks._EagerTaskFactoryType.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "asyncio.tasks._EagerTaskFactoryType";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tasks.as_completed";
    rf.short_name = "as_completed";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tasks.ensure_future";
    rf.short_name = "ensure_future";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tasks.gather";
    rf.short_name = "gather";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tasks.run_coroutine_threadsafe";
    rf.short_name = "run_coroutine_threadsafe";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tasks.shield";
    rf.short_name = "shield";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tasks.sleep";
    rf.short_name = "sleep";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tasks.wait_for";
    rf.short_name = "wait_for";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tasks.wait";
    rf.short_name = "wait";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tasks.all_tasks";
    rf.short_name = "all_tasks";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tasks.create_task";
    rf.short_name = "create_task";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tasks.current_task";
    rf.short_name = "current_task";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tasks.eager_task_factory";
    rf.short_name = "eager_task_factory";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tasks.create_eager_task_factory";
    rf.short_name = "create_eager_task_factory";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.threads ===== */
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.threads.to_thread";
    rf.short_name = "to_thread";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.timeouts ===== */
    static const char* py_methods_157[] = { "__init__", "when", "reschedule", "expired", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.timeouts.Timeout";
    rt.short_name = "Timeout";
    rt.method_names = py_methods_157;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.timeouts.Timeout.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.timeouts.Timeout";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.timeouts.Timeout.when";
    rf.short_name = "when";
    rf.receiver_type = "asyncio.timeouts.Timeout";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.timeouts.Timeout.reschedule";
    rf.short_name = "reschedule";
    rf.receiver_type = "asyncio.timeouts.Timeout";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.timeouts.Timeout.expired";
    rf.short_name = "expired";
    rf.receiver_type = "asyncio.timeouts.Timeout";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.timeouts.timeout";
    rf.short_name = "timeout";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.timeouts.timeout_at";
    rf.short_name = "timeout_at";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.tools ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.tools._AwaitedInfo";
    rt.short_name = "_AwaitedInfo";
    static const char* py_bases_158[] = { "asyncio.tools.NamedTuple", NULL };
    rt.embedded_types = py_bases_158;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.tools._TaskInfo";
    rt.short_name = "_TaskInfo";
    static const char* py_bases_159[] = { "asyncio.tools.NamedTuple", NULL };
    rt.embedded_types = py_bases_159;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.tools._CoroInfo";
    rt.short_name = "_CoroInfo";
    static const char* py_bases_160[] = { "asyncio.tools.NamedTuple", NULL };
    rt.embedded_types = py_bases_160;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.tools._FrameInfo";
    rt.short_name = "_FrameInfo";
    static const char* py_bases_161[] = { "asyncio.tools.NamedTuple", NULL };
    rt.embedded_types = py_bases_161;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.tools.NodeType";
    rt.short_name = "NodeType";
    static const char* py_bases_162[] = { "asyncio.tools.Enum", NULL };
    rt.embedded_types = py_bases_162;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_163[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.tools.CycleFoundException";
    rt.short_name = "CycleFoundException";
    rt.method_names = py_methods_163;
    static const char* py_bases_164[] = { "asyncio.tools.Exception", NULL };
    rt.embedded_types = py_bases_164;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tools.CycleFoundException.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.tools.CycleFoundException";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tools.get_all_awaited_by";
    rf.short_name = "get_all_awaited_by";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tools.build_async_tree";
    rf.short_name = "build_async_tree";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tools.build_task_table";
    rf.short_name = "build_task_table";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tools.exit_with_permission_help_text";
    rf.short_name = "exit_with_permission_help_text";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tools.display_awaited_by_tasks_table";
    rf.short_name = "display_awaited_by_tasks_table";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.tools.display_awaited_by_tasks_tree";
    rf.short_name = "display_awaited_by_tasks_tree";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.transports ===== */
    static const char* py_methods_165[] = { "__init__", "get_extra_info", "is_closing", "close", "set_protocol", "get_protocol", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.transports.BaseTransport";
    rt.short_name = "BaseTransport";
    rt.method_names = py_methods_165;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.BaseTransport.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.transports.BaseTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.BaseTransport.get_extra_info";
    rf.short_name = "get_extra_info";
    rf.receiver_type = "asyncio.transports.BaseTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.BaseTransport.is_closing";
    rf.short_name = "is_closing";
    rf.receiver_type = "asyncio.transports.BaseTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.BaseTransport.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.transports.BaseTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.BaseTransport.set_protocol";
    rf.short_name = "set_protocol";
    rf.receiver_type = "asyncio.transports.BaseTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.BaseTransport.get_protocol";
    rf.short_name = "get_protocol";
    rf.receiver_type = "asyncio.transports.BaseTransport";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_166[] = { "is_reading", "pause_reading", "resume_reading", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.transports.ReadTransport";
    rt.short_name = "ReadTransport";
    rt.method_names = py_methods_166;
    static const char* py_bases_167[] = { "asyncio.transports.BaseTransport", NULL };
    rt.embedded_types = py_bases_167;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.ReadTransport.is_reading";
    rf.short_name = "is_reading";
    rf.receiver_type = "asyncio.transports.ReadTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.ReadTransport.pause_reading";
    rf.short_name = "pause_reading";
    rf.receiver_type = "asyncio.transports.ReadTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.ReadTransport.resume_reading";
    rf.short_name = "resume_reading";
    rf.receiver_type = "asyncio.transports.ReadTransport";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_168[] = { "set_write_buffer_limits", "get_write_buffer_size", "get_write_buffer_limits", "write", "writelines", "write_eof", "can_write_eof", "abort", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.transports.WriteTransport";
    rt.short_name = "WriteTransport";
    rt.method_names = py_methods_168;
    static const char* py_bases_169[] = { "asyncio.transports.BaseTransport", NULL };
    rt.embedded_types = py_bases_169;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.WriteTransport.set_write_buffer_limits";
    rf.short_name = "set_write_buffer_limits";
    rf.receiver_type = "asyncio.transports.WriteTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.WriteTransport.get_write_buffer_size";
    rf.short_name = "get_write_buffer_size";
    rf.receiver_type = "asyncio.transports.WriteTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.WriteTransport.get_write_buffer_limits";
    rf.short_name = "get_write_buffer_limits";
    rf.receiver_type = "asyncio.transports.WriteTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.WriteTransport.write";
    rf.short_name = "write";
    rf.receiver_type = "asyncio.transports.WriteTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.WriteTransport.writelines";
    rf.short_name = "writelines";
    rf.receiver_type = "asyncio.transports.WriteTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.WriteTransport.write_eof";
    rf.short_name = "write_eof";
    rf.receiver_type = "asyncio.transports.WriteTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.WriteTransport.can_write_eof";
    rf.short_name = "can_write_eof";
    rf.receiver_type = "asyncio.transports.WriteTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.WriteTransport.abort";
    rf.short_name = "abort";
    rf.receiver_type = "asyncio.transports.WriteTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.transports.Transport";
    rt.short_name = "Transport";
    static const char* py_bases_170[] = { "asyncio.transports.ReadTransport", "asyncio.transports.WriteTransport", NULL };
    rt.embedded_types = py_bases_170;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_171[] = { "sendto", "abort", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.transports.DatagramTransport";
    rt.short_name = "DatagramTransport";
    rt.method_names = py_methods_171;
    static const char* py_bases_172[] = { "asyncio.transports.BaseTransport", NULL };
    rt.embedded_types = py_bases_172;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.DatagramTransport.sendto";
    rf.short_name = "sendto";
    rf.receiver_type = "asyncio.transports.DatagramTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.DatagramTransport.abort";
    rf.short_name = "abort";
    rf.receiver_type = "asyncio.transports.DatagramTransport";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_173[] = { "get_pid", "get_returncode", "get_pipe_transport", "send_signal", "terminate", "kill", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.transports.SubprocessTransport";
    rt.short_name = "SubprocessTransport";
    rt.method_names = py_methods_173;
    static const char* py_bases_174[] = { "asyncio.transports.BaseTransport", NULL };
    rt.embedded_types = py_bases_174;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.SubprocessTransport.get_pid";
    rf.short_name = "get_pid";
    rf.receiver_type = "asyncio.transports.SubprocessTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.SubprocessTransport.get_returncode";
    rf.short_name = "get_returncode";
    rf.receiver_type = "asyncio.transports.SubprocessTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.SubprocessTransport.get_pipe_transport";
    rf.short_name = "get_pipe_transport";
    rf.receiver_type = "asyncio.transports.SubprocessTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.SubprocessTransport.send_signal";
    rf.short_name = "send_signal";
    rf.receiver_type = "asyncio.transports.SubprocessTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.SubprocessTransport.terminate";
    rf.short_name = "terminate";
    rf.receiver_type = "asyncio.transports.SubprocessTransport";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports.SubprocessTransport.kill";
    rf.short_name = "kill";
    rf.receiver_type = "asyncio.transports.SubprocessTransport";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_175[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.transports._FlowControlMixin";
    rt.short_name = "_FlowControlMixin";
    rt.method_names = py_methods_175;
    static const char* py_bases_176[] = { "asyncio.transports.Transport", NULL };
    rt.embedded_types = py_bases_176;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.transports._FlowControlMixin.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.transports._FlowControlMixin";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.trsock ===== */
    static const char* py_methods_177[] = { "__init__", "family", "type", "proto", "fileno", "dup", "get_inheritable", "shutdown", "getsockopt", "setsockopt", "getpeername", "getsockname", "getsockbyname", "settimeout", "gettimeout", "setblocking", "_na", "accept", "connect", "connect_ex", "bind", "listen", "makefile", "sendfile", "close", "detach", "sendmsg", "sendto", "send", "sendall", "set_inheritable", "recv_into", "recvfrom_into", "recvmsg_into", "recvmsg", "recvfrom", "recv", "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.trsock.TransportSocket";
    rt.short_name = "TransportSocket";
    rt.method_names = py_methods_177;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.family";
    rf.short_name = "family";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.type";
    rf.short_name = "type";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.proto";
    rf.short_name = "proto";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.fileno";
    rf.short_name = "fileno";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.dup";
    rf.short_name = "dup";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.get_inheritable";
    rf.short_name = "get_inheritable";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.shutdown";
    rf.short_name = "shutdown";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.getsockopt";
    rf.short_name = "getsockopt";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.setsockopt";
    rf.short_name = "setsockopt";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.getpeername";
    rf.short_name = "getpeername";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.getsockname";
    rf.short_name = "getsockname";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.getsockbyname";
    rf.short_name = "getsockbyname";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.settimeout";
    rf.short_name = "settimeout";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.gettimeout";
    rf.short_name = "gettimeout";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.setblocking";
    rf.short_name = "setblocking";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket._na";
    rf.short_name = "_na";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.accept";
    rf.short_name = "accept";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.connect";
    rf.short_name = "connect";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.connect_ex";
    rf.short_name = "connect_ex";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.bind";
    rf.short_name = "bind";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.listen";
    rf.short_name = "listen";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.makefile";
    rf.short_name = "makefile";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.sendfile";
    rf.short_name = "sendfile";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.detach";
    rf.short_name = "detach";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.sendmsg";
    rf.short_name = "sendmsg";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.sendto";
    rf.short_name = "sendto";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.send";
    rf.short_name = "send";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.sendall";
    rf.short_name = "sendall";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.set_inheritable";
    rf.short_name = "set_inheritable";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.recv_into";
    rf.short_name = "recv_into";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.recvfrom_into";
    rf.short_name = "recvfrom_into";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.recvmsg_into";
    rf.short_name = "recvmsg_into";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.recvmsg";
    rf.short_name = "recvmsg";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.recvfrom";
    rf.short_name = "recvfrom";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.recv";
    rf.short_name = "recv";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.trsock.TransportSocket.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "asyncio.trsock.TransportSocket";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.unix_events ===== */
    static const char* py_methods_178[] = { "add_child_handler", "remove_child_handler", "attach_loop", "close", "__enter__", "__exit__", "is_active", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.unix_events.AbstractChildWatcher";
    rt.short_name = "AbstractChildWatcher";
    rt.method_names = py_methods_178;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.add_child_handler";
    rf.short_name = "add_child_handler";
    rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.remove_child_handler";
    rf.short_name = "remove_child_handler";
    rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.attach_loop";
    rf.short_name = "attach_loop";
    rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.is_active";
    rf.short_name = "is_active";
    rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_179[] = { "add_child_handler", "remove_child_handler", "attach_loop", "close", "__enter__", "__exit__", "is_active", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.unix_events.AbstractChildWatcher";
    rt.short_name = "AbstractChildWatcher";
    rt.method_names = py_methods_179;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.add_child_handler";
    rf.short_name = "add_child_handler";
    rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.remove_child_handler";
    rf.short_name = "remove_child_handler";
    rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.attach_loop";
    rf.short_name = "attach_loop";
    rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.AbstractChildWatcher.is_active";
    rf.short_name = "is_active";
    rf.receiver_type = "asyncio.unix_events.AbstractChildWatcher";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_180[] = { "close", "is_active", "attach_loop", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.unix_events.BaseChildWatcher";
    rt.short_name = "BaseChildWatcher";
    rt.method_names = py_methods_180;
    static const char* py_bases_181[] = { "asyncio.unix_events.AbstractChildWatcher", NULL };
    rt.embedded_types = py_bases_181;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.BaseChildWatcher.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.unix_events.BaseChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.BaseChildWatcher.is_active";
    rf.short_name = "is_active";
    rf.receiver_type = "asyncio.unix_events.BaseChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.BaseChildWatcher.attach_loop";
    rf.short_name = "attach_loop";
    rf.receiver_type = "asyncio.unix_events.BaseChildWatcher";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_182[] = { "__enter__", "__exit__", "add_child_handler", "remove_child_handler", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.unix_events.SafeChildWatcher";
    rt.short_name = "SafeChildWatcher";
    rt.method_names = py_methods_182;
    static const char* py_bases_183[] = { "asyncio.unix_events.BaseChildWatcher", NULL };
    rt.embedded_types = py_bases_183;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "asyncio.unix_events.SafeChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "asyncio.unix_events.SafeChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.add_child_handler";
    rf.short_name = "add_child_handler";
    rf.receiver_type = "asyncio.unix_events.SafeChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.remove_child_handler";
    rf.short_name = "remove_child_handler";
    rf.receiver_type = "asyncio.unix_events.SafeChildWatcher";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_184[] = { "__enter__", "__exit__", "add_child_handler", "remove_child_handler", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.unix_events.FastChildWatcher";
    rt.short_name = "FastChildWatcher";
    rt.method_names = py_methods_184;
    static const char* py_bases_185[] = { "asyncio.unix_events.BaseChildWatcher", NULL };
    rt.embedded_types = py_bases_185;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.FastChildWatcher.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "asyncio.unix_events.FastChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.FastChildWatcher.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "asyncio.unix_events.FastChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.FastChildWatcher.add_child_handler";
    rf.short_name = "add_child_handler";
    rf.receiver_type = "asyncio.unix_events.FastChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.FastChildWatcher.remove_child_handler";
    rf.short_name = "remove_child_handler";
    rf.receiver_type = "asyncio.unix_events.FastChildWatcher";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_186[] = { "close", "is_active", "attach_loop", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.unix_events.BaseChildWatcher";
    rt.short_name = "BaseChildWatcher";
    rt.method_names = py_methods_186;
    static const char* py_bases_187[] = { "asyncio.unix_events.AbstractChildWatcher", NULL };
    rt.embedded_types = py_bases_187;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.BaseChildWatcher.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.unix_events.BaseChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.BaseChildWatcher.is_active";
    rf.short_name = "is_active";
    rf.receiver_type = "asyncio.unix_events.BaseChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.BaseChildWatcher.attach_loop";
    rf.short_name = "attach_loop";
    rf.receiver_type = "asyncio.unix_events.BaseChildWatcher";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_188[] = { "__enter__", "__exit__", "add_child_handler", "remove_child_handler", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.unix_events.SafeChildWatcher";
    rt.short_name = "SafeChildWatcher";
    rt.method_names = py_methods_188;
    static const char* py_bases_189[] = { "asyncio.unix_events.BaseChildWatcher", NULL };
    rt.embedded_types = py_bases_189;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "asyncio.unix_events.SafeChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "asyncio.unix_events.SafeChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.add_child_handler";
    rf.short_name = "add_child_handler";
    rf.receiver_type = "asyncio.unix_events.SafeChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.SafeChildWatcher.remove_child_handler";
    rf.short_name = "remove_child_handler";
    rf.receiver_type = "asyncio.unix_events.SafeChildWatcher";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_190[] = { "__enter__", "__exit__", "add_child_handler", "remove_child_handler", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.unix_events.FastChildWatcher";
    rt.short_name = "FastChildWatcher";
    rt.method_names = py_methods_190;
    static const char* py_bases_191[] = { "asyncio.unix_events.BaseChildWatcher", NULL };
    rt.embedded_types = py_bases_191;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.FastChildWatcher.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "asyncio.unix_events.FastChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.FastChildWatcher.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "asyncio.unix_events.FastChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.FastChildWatcher.add_child_handler";
    rf.short_name = "add_child_handler";
    rf.receiver_type = "asyncio.unix_events.FastChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.FastChildWatcher.remove_child_handler";
    rf.short_name = "remove_child_handler";
    rf.receiver_type = "asyncio.unix_events.FastChildWatcher";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_192[] = { "create_unix_server", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.unix_events._UnixSelectorEventLoop";
    rt.short_name = "_UnixSelectorEventLoop";
    rt.method_names = py_methods_192;
    static const char* py_bases_193[] = { "asyncio.unix_events.BaseSelectorEventLoop", NULL };
    rt.embedded_types = py_bases_193;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events._UnixSelectorEventLoop.create_unix_server";
    rf.short_name = "create_unix_server";
    rf.receiver_type = "asyncio.unix_events._UnixSelectorEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.unix_events._UnixDefaultEventLoopPolicy";
    rt.short_name = "_UnixDefaultEventLoopPolicy";
    static const char* py_bases_194[] = { "events._BaseDefaultEventLoopPolicy", NULL };
    rt.embedded_types = py_bases_194;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_195[] = { "get_child_watcher", "set_child_watcher", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.unix_events._UnixDefaultEventLoopPolicy";
    rt.short_name = "_UnixDefaultEventLoopPolicy";
    rt.method_names = py_methods_195;
    static const char* py_bases_196[] = { "events.BaseDefaultEventLoopPolicy", NULL };
    rt.embedded_types = py_bases_196;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events._UnixDefaultEventLoopPolicy.get_child_watcher";
    rf.short_name = "get_child_watcher";
    rf.receiver_type = "asyncio.unix_events._UnixDefaultEventLoopPolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events._UnixDefaultEventLoopPolicy.set_child_watcher";
    rf.short_name = "set_child_watcher";
    rf.receiver_type = "asyncio.unix_events._UnixDefaultEventLoopPolicy";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_197[] = { "is_active", "close", "__enter__", "__exit__", "add_child_handler", "remove_child_handler", "attach_loop", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.unix_events.MultiLoopChildWatcher";
    rt.short_name = "MultiLoopChildWatcher";
    rt.method_names = py_methods_197;
    static const char* py_bases_198[] = { "asyncio.unix_events.AbstractChildWatcher", NULL };
    rt.embedded_types = py_bases_198;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.MultiLoopChildWatcher.is_active";
    rf.short_name = "is_active";
    rf.receiver_type = "asyncio.unix_events.MultiLoopChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.MultiLoopChildWatcher.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.unix_events.MultiLoopChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.MultiLoopChildWatcher.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "asyncio.unix_events.MultiLoopChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.MultiLoopChildWatcher.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "asyncio.unix_events.MultiLoopChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.MultiLoopChildWatcher.add_child_handler";
    rf.short_name = "add_child_handler";
    rf.receiver_type = "asyncio.unix_events.MultiLoopChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.MultiLoopChildWatcher.remove_child_handler";
    rf.short_name = "remove_child_handler";
    rf.receiver_type = "asyncio.unix_events.MultiLoopChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.MultiLoopChildWatcher.attach_loop";
    rf.short_name = "attach_loop";
    rf.receiver_type = "asyncio.unix_events.MultiLoopChildWatcher";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_199[] = { "is_active", "close", "__enter__", "__exit__", "add_child_handler", "remove_child_handler", "attach_loop", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.unix_events.ThreadedChildWatcher";
    rt.short_name = "ThreadedChildWatcher";
    rt.method_names = py_methods_199;
    static const char* py_bases_200[] = { "asyncio.unix_events.AbstractChildWatcher", NULL };
    rt.embedded_types = py_bases_200;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.ThreadedChildWatcher.is_active";
    rf.short_name = "is_active";
    rf.receiver_type = "asyncio.unix_events.ThreadedChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.ThreadedChildWatcher.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.unix_events.ThreadedChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.ThreadedChildWatcher.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "asyncio.unix_events.ThreadedChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.ThreadedChildWatcher.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "asyncio.unix_events.ThreadedChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.ThreadedChildWatcher.add_child_handler";
    rf.short_name = "add_child_handler";
    rf.receiver_type = "asyncio.unix_events.ThreadedChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.ThreadedChildWatcher.remove_child_handler";
    rf.short_name = "remove_child_handler";
    rf.receiver_type = "asyncio.unix_events.ThreadedChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.ThreadedChildWatcher.attach_loop";
    rf.short_name = "attach_loop";
    rf.receiver_type = "asyncio.unix_events.ThreadedChildWatcher";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_201[] = { "__enter__", "__exit__", "is_active", "close", "attach_loop", "add_child_handler", "remove_child_handler", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.unix_events.PidfdChildWatcher";
    rt.short_name = "PidfdChildWatcher";
    rt.method_names = py_methods_201;
    static const char* py_bases_202[] = { "asyncio.unix_events.AbstractChildWatcher", NULL };
    rt.embedded_types = py_bases_202;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.PidfdChildWatcher.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "asyncio.unix_events.PidfdChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.PidfdChildWatcher.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "asyncio.unix_events.PidfdChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.PidfdChildWatcher.is_active";
    rf.short_name = "is_active";
    rf.receiver_type = "asyncio.unix_events.PidfdChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.PidfdChildWatcher.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.unix_events.PidfdChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.PidfdChildWatcher.attach_loop";
    rf.short_name = "attach_loop";
    rf.receiver_type = "asyncio.unix_events.PidfdChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.PidfdChildWatcher.add_child_handler";
    rf.short_name = "add_child_handler";
    rf.receiver_type = "asyncio.unix_events.PidfdChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.PidfdChildWatcher.remove_child_handler";
    rf.short_name = "remove_child_handler";
    rf.receiver_type = "asyncio.unix_events.PidfdChildWatcher";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_203[] = { "is_active", "close", "__enter__", "__exit__", "add_child_handler", "remove_child_handler", "attach_loop", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.unix_events.MultiLoopChildWatcher";
    rt.short_name = "MultiLoopChildWatcher";
    rt.method_names = py_methods_203;
    static const char* py_bases_204[] = { "asyncio.unix_events.AbstractChildWatcher", NULL };
    rt.embedded_types = py_bases_204;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.MultiLoopChildWatcher.is_active";
    rf.short_name = "is_active";
    rf.receiver_type = "asyncio.unix_events.MultiLoopChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.MultiLoopChildWatcher.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.unix_events.MultiLoopChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.MultiLoopChildWatcher.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "asyncio.unix_events.MultiLoopChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.MultiLoopChildWatcher.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "asyncio.unix_events.MultiLoopChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.MultiLoopChildWatcher.add_child_handler";
    rf.short_name = "add_child_handler";
    rf.receiver_type = "asyncio.unix_events.MultiLoopChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.MultiLoopChildWatcher.remove_child_handler";
    rf.short_name = "remove_child_handler";
    rf.receiver_type = "asyncio.unix_events.MultiLoopChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.MultiLoopChildWatcher.attach_loop";
    rf.short_name = "attach_loop";
    rf.receiver_type = "asyncio.unix_events.MultiLoopChildWatcher";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_205[] = { "is_active", "close", "__enter__", "__exit__", "add_child_handler", "remove_child_handler", "attach_loop", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.unix_events.ThreadedChildWatcher";
    rt.short_name = "ThreadedChildWatcher";
    rt.method_names = py_methods_205;
    static const char* py_bases_206[] = { "asyncio.unix_events.AbstractChildWatcher", NULL };
    rt.embedded_types = py_bases_206;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.ThreadedChildWatcher.is_active";
    rf.short_name = "is_active";
    rf.receiver_type = "asyncio.unix_events.ThreadedChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.ThreadedChildWatcher.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.unix_events.ThreadedChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.ThreadedChildWatcher.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "asyncio.unix_events.ThreadedChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.ThreadedChildWatcher.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "asyncio.unix_events.ThreadedChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.ThreadedChildWatcher.add_child_handler";
    rf.short_name = "add_child_handler";
    rf.receiver_type = "asyncio.unix_events.ThreadedChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.ThreadedChildWatcher.remove_child_handler";
    rf.short_name = "remove_child_handler";
    rf.receiver_type = "asyncio.unix_events.ThreadedChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.ThreadedChildWatcher.attach_loop";
    rf.short_name = "attach_loop";
    rf.receiver_type = "asyncio.unix_events.ThreadedChildWatcher";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_207[] = { "__enter__", "__exit__", "is_active", "close", "attach_loop", "add_child_handler", "remove_child_handler", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.unix_events.PidfdChildWatcher";
    rt.short_name = "PidfdChildWatcher";
    rt.method_names = py_methods_207;
    static const char* py_bases_208[] = { "asyncio.unix_events.AbstractChildWatcher", NULL };
    rt.embedded_types = py_bases_208;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.PidfdChildWatcher.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "asyncio.unix_events.PidfdChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.PidfdChildWatcher.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "asyncio.unix_events.PidfdChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.PidfdChildWatcher.is_active";
    rf.short_name = "is_active";
    rf.receiver_type = "asyncio.unix_events.PidfdChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.PidfdChildWatcher.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.unix_events.PidfdChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.PidfdChildWatcher.attach_loop";
    rf.short_name = "attach_loop";
    rf.receiver_type = "asyncio.unix_events.PidfdChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.PidfdChildWatcher.add_child_handler";
    rf.short_name = "add_child_handler";
    rf.receiver_type = "asyncio.unix_events.PidfdChildWatcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.unix_events.PidfdChildWatcher.remove_child_handler";
    rf.short_name = "remove_child_handler";
    rf.receiver_type = "asyncio.unix_events.PidfdChildWatcher";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.windows_events ===== */
    static const char* py_methods_209[] = { "__init__", "closed", "close", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.windows_events.PipeServer";
    rt.short_name = "PipeServer";
    rt.method_names = py_methods_209;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.PipeServer.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.windows_events.PipeServer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.PipeServer.closed";
    rf.short_name = "closed";
    rf.receiver_type = "asyncio.windows_events.PipeServer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.PipeServer.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.windows_events.PipeServer";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.windows_events._WindowsSelectorEventLoop";
    rt.short_name = "_WindowsSelectorEventLoop";
    static const char* py_bases_210[] = { "selector_events.BaseSelectorEventLoop", NULL };
    rt.embedded_types = py_bases_210;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_211[] = { "__init__", "create_pipe_connection", "start_serving_pipe", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.windows_events.ProactorEventLoop";
    rt.short_name = "ProactorEventLoop";
    rt.method_names = py_methods_211;
    static const char* py_bases_212[] = { "proactor_events.BaseProactorEventLoop", NULL };
    rt.embedded_types = py_bases_212;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.ProactorEventLoop.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.windows_events.ProactorEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.ProactorEventLoop.create_pipe_connection";
    rf.short_name = "create_pipe_connection";
    rf.receiver_type = "asyncio.windows_events.ProactorEventLoop";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.ProactorEventLoop.start_serving_pipe";
    rf.short_name = "start_serving_pipe";
    rf.receiver_type = "asyncio.windows_events.ProactorEventLoop";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_213[] = { "__init__", "set_loop", "select", "recv", "recv_into", "recvfrom", "sendto", "send", "accept", "connect", "sendfile", "accept_pipe", "connect_pipe", "wait_for_handle", "close", "recvfrom_into", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.windows_events.IocpProactor";
    rt.short_name = "IocpProactor";
    rt.method_names = py_methods_213;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.IocpProactor.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.windows_events.IocpProactor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.IocpProactor.set_loop";
    rf.short_name = "set_loop";
    rf.receiver_type = "asyncio.windows_events.IocpProactor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.IocpProactor.select";
    rf.short_name = "select";
    rf.receiver_type = "asyncio.windows_events.IocpProactor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.IocpProactor.recv";
    rf.short_name = "recv";
    rf.receiver_type = "asyncio.windows_events.IocpProactor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.IocpProactor.recv_into";
    rf.short_name = "recv_into";
    rf.receiver_type = "asyncio.windows_events.IocpProactor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.IocpProactor.recvfrom";
    rf.short_name = "recvfrom";
    rf.receiver_type = "asyncio.windows_events.IocpProactor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.IocpProactor.sendto";
    rf.short_name = "sendto";
    rf.receiver_type = "asyncio.windows_events.IocpProactor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.IocpProactor.send";
    rf.short_name = "send";
    rf.receiver_type = "asyncio.windows_events.IocpProactor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.IocpProactor.accept";
    rf.short_name = "accept";
    rf.receiver_type = "asyncio.windows_events.IocpProactor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.IocpProactor.connect";
    rf.short_name = "connect";
    rf.receiver_type = "asyncio.windows_events.IocpProactor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.IocpProactor.sendfile";
    rf.short_name = "sendfile";
    rf.receiver_type = "asyncio.windows_events.IocpProactor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.IocpProactor.accept_pipe";
    rf.short_name = "accept_pipe";
    rf.receiver_type = "asyncio.windows_events.IocpProactor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.IocpProactor.connect_pipe";
    rf.short_name = "connect_pipe";
    rf.receiver_type = "asyncio.windows_events.IocpProactor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.IocpProactor.wait_for_handle";
    rf.short_name = "wait_for_handle";
    rf.receiver_type = "asyncio.windows_events.IocpProactor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.IocpProactor.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.windows_events.IocpProactor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.IocpProactor.recvfrom_into";
    rf.short_name = "recvfrom_into";
    rf.receiver_type = "asyncio.windows_events.IocpProactor";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.windows_events._WindowsSelectorEventLoopPolicy";
    rt.short_name = "_WindowsSelectorEventLoopPolicy";
    static const char* py_bases_214[] = { "events._BaseDefaultEventLoopPolicy", NULL };
    rt.embedded_types = py_bases_214;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.windows_events._WindowsProactorEventLoopPolicy";
    rt.short_name = "_WindowsProactorEventLoopPolicy";
    static const char* py_bases_215[] = { "events._BaseDefaultEventLoopPolicy", NULL };
    rt.embedded_types = py_bases_215;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_216[] = { "get_child_watcher", "set_child_watcher", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.windows_events.WindowsSelectorEventLoopPolicy";
    rt.short_name = "WindowsSelectorEventLoopPolicy";
    rt.method_names = py_methods_216;
    static const char* py_bases_217[] = { "events.BaseDefaultEventLoopPolicy", NULL };
    rt.embedded_types = py_bases_217;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.WindowsSelectorEventLoopPolicy.get_child_watcher";
    rf.short_name = "get_child_watcher";
    rf.receiver_type = "asyncio.windows_events.WindowsSelectorEventLoopPolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.WindowsSelectorEventLoopPolicy.set_child_watcher";
    rf.short_name = "set_child_watcher";
    rf.receiver_type = "asyncio.windows_events.WindowsSelectorEventLoopPolicy";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_218[] = { "get_child_watcher", "set_child_watcher", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.windows_events.WindowsProactorEventLoopPolicy";
    rt.short_name = "WindowsProactorEventLoopPolicy";
    rt.method_names = py_methods_218;
    static const char* py_bases_219[] = { "events.BaseDefaultEventLoopPolicy", NULL };
    rt.embedded_types = py_bases_219;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.WindowsProactorEventLoopPolicy.get_child_watcher";
    rf.short_name = "get_child_watcher";
    rf.receiver_type = "asyncio.windows_events.WindowsProactorEventLoopPolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_events.WindowsProactorEventLoopPolicy.set_child_watcher";
    rf.short_name = "set_child_watcher";
    rf.receiver_type = "asyncio.windows_events.WindowsProactorEventLoopPolicy";
    cbm_registry_add_func(reg, rf);

    /* ===== module: asyncio.windows_utils ===== */
    static const char* py_methods_220[] = { "__init__", "__enter__", "__exit__", "handle", "fileno", "close", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.windows_utils.PipeHandle";
    rt.short_name = "PipeHandle";
    rt.method_names = py_methods_220;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_utils.PipeHandle.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.windows_utils.PipeHandle";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_utils.PipeHandle.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "asyncio.windows_utils.PipeHandle";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_utils.PipeHandle.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "asyncio.windows_utils.PipeHandle";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_utils.PipeHandle.handle";
    rf.short_name = "handle";
    rf.receiver_type = "asyncio.windows_utils.PipeHandle";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_utils.PipeHandle.fileno";
    rf.short_name = "fileno";
    rf.receiver_type = "asyncio.windows_utils.PipeHandle";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_utils.PipeHandle.close";
    rf.short_name = "close";
    rf.receiver_type = "asyncio.windows_utils.PipeHandle";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_221[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "asyncio.windows_utils.Popen";
    rt.short_name = "Popen";
    rt.method_names = py_methods_221;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_utils.Popen.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "asyncio.windows_utils.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "asyncio.windows_utils.pipe";
    rf.short_name = "pipe";
    cbm_registry_add_func(reg, rf);

    /* ===== module: builtins ===== */
    static const char* py_methods_222[] = { "__init__", "__getstate__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.object";
    rt.short_name = "object";
    rt.method_names = py_methods_222;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.object.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.object";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.object.__getstate__";
    rf.short_name = "__getstate__";
    rf.receiver_type = "builtins.object";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_223[] = { "__init__", "__call__", "__class_getitem__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.staticmethod";
    rt.short_name = "staticmethod";
    rt.method_names = py_methods_223;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.staticmethod.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.staticmethod";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.staticmethod.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "builtins.staticmethod";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.staticmethod.__class_getitem__";
    rf.short_name = "__class_getitem__";
    rf.receiver_type = "builtins.staticmethod";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_224[] = { "__init__", "__class_getitem__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.classmethod";
    rt.short_name = "classmethod";
    rt.method_names = py_methods_224;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.classmethod.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.classmethod";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.classmethod.__class_getitem__";
    rf.short_name = "__class_getitem__";
    rf.receiver_type = "builtins.classmethod";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_225[] = { "__init__", "__call__", "mro", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.type";
    rt.short_name = "type";
    rt.method_names = py_methods_225;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.type.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.type";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.type.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "builtins.type";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.type.mro";
    rf.short_name = "mro";
    rf.receiver_type = "builtins.type";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_226[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.super";
    rt.short_name = "super";
    rt.method_names = py_methods_226;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.super.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.super";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_227[] = { "as_integer_ratio", "real", "imag", "numerator", "denominator", "conjugate", "bit_length", "bit_count", "to_bytes", "from_bytes", "is_integer", "__round__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.int";
    rt.short_name = "int";
    rt.method_names = py_methods_227;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.int.as_integer_ratio";
    rf.short_name = "as_integer_ratio";
    rf.receiver_type = "builtins.int";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.int.real";
    rf.short_name = "real";
    rf.receiver_type = "builtins.int";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.int.imag";
    rf.short_name = "imag";
    rf.receiver_type = "builtins.int";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.int.numerator";
    rf.short_name = "numerator";
    rf.receiver_type = "builtins.int";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.int.denominator";
    rf.short_name = "denominator";
    rf.receiver_type = "builtins.int";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.int.conjugate";
    rf.short_name = "conjugate";
    rf.receiver_type = "builtins.int";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.int.bit_length";
    rf.short_name = "bit_length";
    rf.receiver_type = "builtins.int";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.int.bit_count";
    rf.short_name = "bit_count";
    rf.receiver_type = "builtins.int";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.int.to_bytes";
    rf.short_name = "to_bytes";
    rf.receiver_type = "builtins.int";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.int.from_bytes";
    rf.short_name = "from_bytes";
    rf.receiver_type = "builtins.int";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.int.is_integer";
    rf.short_name = "is_integer";
    rf.receiver_type = "builtins.int";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.int.__round__";
    rf.short_name = "__round__";
    rf.receiver_type = "builtins.int";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_228[] = { "as_integer_ratio", "hex", "is_integer", "fromhex", "real", "imag", "conjugate", "from_number", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.float";
    rt.short_name = "float";
    rt.method_names = py_methods_228;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.float.as_integer_ratio";
    rf.short_name = "as_integer_ratio";
    rf.receiver_type = "builtins.float";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.float.hex";
    rf.short_name = "hex";
    rf.receiver_type = "builtins.float";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.float.is_integer";
    rf.short_name = "is_integer";
    rf.receiver_type = "builtins.float";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.float.fromhex";
    rf.short_name = "fromhex";
    rf.receiver_type = "builtins.float";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.float.real";
    rf.short_name = "real";
    rf.receiver_type = "builtins.float";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.float.imag";
    rf.short_name = "imag";
    rf.receiver_type = "builtins.float";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.float.conjugate";
    rf.short_name = "conjugate";
    rf.receiver_type = "builtins.float";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.float.from_number";
    rf.short_name = "from_number";
    rf.receiver_type = "builtins.float";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_229[] = { "real", "imag", "conjugate", "__complex__", "from_number", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.complex";
    rt.short_name = "complex";
    rt.method_names = py_methods_229;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.complex.real";
    rf.short_name = "real";
    rf.receiver_type = "builtins.complex";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.complex.imag";
    rf.short_name = "imag";
    rf.receiver_type = "builtins.complex";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.complex.conjugate";
    rf.short_name = "conjugate";
    rf.receiver_type = "builtins.complex";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.complex.__complex__";
    rf.short_name = "__complex__";
    rf.receiver_type = "builtins.complex";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.complex.from_number";
    rf.short_name = "from_number";
    rf.receiver_type = "builtins.complex";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins._FormatMapMapping";
    rt.short_name = "_FormatMapMapping";
    static const char* py_bases_230[] = { "builtins.Protocol", NULL };
    rt.embedded_types = py_bases_230;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins._TranslateTable";
    rt.short_name = "_TranslateTable";
    static const char* py_bases_231[] = { "builtins.Protocol", NULL };
    rt.embedded_types = py_bases_231;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_232[] = { "capitalize", "casefold", "center", "count", "encode", "endswith", "expandtabs", "find", "format", "format_map", "index", "isalnum", "isalpha", "isascii", "isdecimal", "isdigit", "isidentifier", "islower", "isnumeric", "isprintable", "isspace", "istitle", "isupper", "join", "ljust", "lower", "lstrip", "partition", "replace", "removeprefix", "removesuffix", "rfind", "rindex", "rjust", "rpartition", "rsplit", "rstrip", "split", "splitlines", "startswith", "strip", "swapcase", "title", "translate", "upper", "zfill", "maketrans", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.str";
    rt.short_name = "str";
    rt.method_names = py_methods_232;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.capitalize";
    rf.short_name = "capitalize";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.casefold";
    rf.short_name = "casefold";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.center";
    rf.short_name = "center";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.count";
    rf.short_name = "count";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.encode";
    rf.short_name = "encode";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.endswith";
    rf.short_name = "endswith";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.expandtabs";
    rf.short_name = "expandtabs";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.find";
    rf.short_name = "find";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.format";
    rf.short_name = "format";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.format_map";
    rf.short_name = "format_map";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.index";
    rf.short_name = "index";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.isalnum";
    rf.short_name = "isalnum";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.isalpha";
    rf.short_name = "isalpha";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.isascii";
    rf.short_name = "isascii";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.isdecimal";
    rf.short_name = "isdecimal";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.isdigit";
    rf.short_name = "isdigit";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.isidentifier";
    rf.short_name = "isidentifier";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.islower";
    rf.short_name = "islower";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.isnumeric";
    rf.short_name = "isnumeric";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.isprintable";
    rf.short_name = "isprintable";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.isspace";
    rf.short_name = "isspace";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.istitle";
    rf.short_name = "istitle";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.isupper";
    rf.short_name = "isupper";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.join";
    rf.short_name = "join";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.ljust";
    rf.short_name = "ljust";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.lower";
    rf.short_name = "lower";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.lstrip";
    rf.short_name = "lstrip";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.partition";
    rf.short_name = "partition";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.replace";
    rf.short_name = "replace";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.removeprefix";
    rf.short_name = "removeprefix";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.removesuffix";
    rf.short_name = "removesuffix";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.rfind";
    rf.short_name = "rfind";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.rindex";
    rf.short_name = "rindex";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.rjust";
    rf.short_name = "rjust";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.rpartition";
    rf.short_name = "rpartition";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.rsplit";
    rf.short_name = "rsplit";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.rstrip";
    rf.short_name = "rstrip";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.split";
    rf.short_name = "split";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.splitlines";
    rf.short_name = "splitlines";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.startswith";
    rf.short_name = "startswith";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.strip";
    rf.short_name = "strip";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.swapcase";
    rf.short_name = "swapcase";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.title";
    rf.short_name = "title";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.translate";
    rf.short_name = "translate";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.upper";
    rf.short_name = "upper";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.zfill";
    rf.short_name = "zfill";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.str.maketrans";
    rf.short_name = "maketrans";
    rf.receiver_type = "builtins.str";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_233[] = { "capitalize", "center", "count", "decode", "endswith", "expandtabs", "find", "hex", "index", "isalnum", "isalpha", "isascii", "isdigit", "islower", "isspace", "istitle", "isupper", "join", "ljust", "lower", "lstrip", "partition", "replace", "removeprefix", "removesuffix", "rfind", "rindex", "rjust", "rpartition", "rsplit", "rstrip", "split", "splitlines", "startswith", "strip", "swapcase", "title", "translate", "upper", "zfill", "fromhex", "maketrans", "__bytes__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.bytes";
    rt.short_name = "bytes";
    rt.method_names = py_methods_233;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.capitalize";
    rf.short_name = "capitalize";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.center";
    rf.short_name = "center";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.count";
    rf.short_name = "count";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.decode";
    rf.short_name = "decode";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.endswith";
    rf.short_name = "endswith";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.expandtabs";
    rf.short_name = "expandtabs";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.find";
    rf.short_name = "find";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.hex";
    rf.short_name = "hex";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.index";
    rf.short_name = "index";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.isalnum";
    rf.short_name = "isalnum";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.isalpha";
    rf.short_name = "isalpha";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.isascii";
    rf.short_name = "isascii";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.isdigit";
    rf.short_name = "isdigit";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.islower";
    rf.short_name = "islower";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.isspace";
    rf.short_name = "isspace";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.istitle";
    rf.short_name = "istitle";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.isupper";
    rf.short_name = "isupper";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.join";
    rf.short_name = "join";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.ljust";
    rf.short_name = "ljust";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.lower";
    rf.short_name = "lower";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.lstrip";
    rf.short_name = "lstrip";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.partition";
    rf.short_name = "partition";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.replace";
    rf.short_name = "replace";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.removeprefix";
    rf.short_name = "removeprefix";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.removesuffix";
    rf.short_name = "removesuffix";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.rfind";
    rf.short_name = "rfind";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.rindex";
    rf.short_name = "rindex";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.rjust";
    rf.short_name = "rjust";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.rpartition";
    rf.short_name = "rpartition";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.rsplit";
    rf.short_name = "rsplit";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.rstrip";
    rf.short_name = "rstrip";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.split";
    rf.short_name = "split";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.splitlines";
    rf.short_name = "splitlines";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.startswith";
    rf.short_name = "startswith";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.strip";
    rf.short_name = "strip";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.swapcase";
    rf.short_name = "swapcase";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.title";
    rf.short_name = "title";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.translate";
    rf.short_name = "translate";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.upper";
    rf.short_name = "upper";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.zfill";
    rf.short_name = "zfill";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.fromhex";
    rf.short_name = "fromhex";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.maketrans";
    rf.short_name = "maketrans";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytes.__bytes__";
    rf.short_name = "__bytes__";
    rf.receiver_type = "builtins.bytes";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_234[] = { "__init__", "append", "capitalize", "center", "count", "copy", "decode", "endswith", "expandtabs", "extend", "find", "hex", "index", "insert", "isalnum", "isalpha", "isascii", "isdigit", "islower", "isspace", "istitle", "isupper", "join", "ljust", "lower", "lstrip", "partition", "pop", "remove", "removeprefix", "removesuffix", "replace", "rfind", "rindex", "rjust", "rpartition", "rsplit", "rstrip", "split", "splitlines", "startswith", "strip", "swapcase", "title", "translate", "take_bytes", "upper", "zfill", "fromhex", "maketrans", "resize", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.bytearray";
    rt.short_name = "bytearray";
    rt.method_names = py_methods_234;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.append";
    rf.short_name = "append";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.capitalize";
    rf.short_name = "capitalize";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.center";
    rf.short_name = "center";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.count";
    rf.short_name = "count";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.copy";
    rf.short_name = "copy";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.decode";
    rf.short_name = "decode";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.endswith";
    rf.short_name = "endswith";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.expandtabs";
    rf.short_name = "expandtabs";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.extend";
    rf.short_name = "extend";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.find";
    rf.short_name = "find";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.hex";
    rf.short_name = "hex";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.index";
    rf.short_name = "index";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.insert";
    rf.short_name = "insert";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.isalnum";
    rf.short_name = "isalnum";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.isalpha";
    rf.short_name = "isalpha";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.isascii";
    rf.short_name = "isascii";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.isdigit";
    rf.short_name = "isdigit";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.islower";
    rf.short_name = "islower";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.isspace";
    rf.short_name = "isspace";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.istitle";
    rf.short_name = "istitle";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.isupper";
    rf.short_name = "isupper";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.join";
    rf.short_name = "join";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.ljust";
    rf.short_name = "ljust";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.lower";
    rf.short_name = "lower";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.lstrip";
    rf.short_name = "lstrip";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.partition";
    rf.short_name = "partition";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.pop";
    rf.short_name = "pop";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.remove";
    rf.short_name = "remove";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.removeprefix";
    rf.short_name = "removeprefix";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.removesuffix";
    rf.short_name = "removesuffix";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.replace";
    rf.short_name = "replace";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.rfind";
    rf.short_name = "rfind";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.rindex";
    rf.short_name = "rindex";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.rjust";
    rf.short_name = "rjust";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.rpartition";
    rf.short_name = "rpartition";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.rsplit";
    rf.short_name = "rsplit";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.rstrip";
    rf.short_name = "rstrip";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.split";
    rf.short_name = "split";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.splitlines";
    rf.short_name = "splitlines";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.startswith";
    rf.short_name = "startswith";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.strip";
    rf.short_name = "strip";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.swapcase";
    rf.short_name = "swapcase";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.title";
    rf.short_name = "title";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.translate";
    rf.short_name = "translate";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.take_bytes";
    rf.short_name = "take_bytes";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.upper";
    rf.short_name = "upper";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.zfill";
    rf.short_name = "zfill";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.fromhex";
    rf.short_name = "fromhex";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.maketrans";
    rf.short_name = "maketrans";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bytearray.resize";
    rf.short_name = "resize";
    rf.receiver_type = "builtins.bytearray";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_235[] = { "format", "itemsize", "shape", "strides", "suboffsets", "readonly", "ndim", "obj", "c_contiguous", "f_contiguous", "contiguous", "nbytes", "__enter__", "__exit__", "cast", "tobytes", "tolist", "toreadonly", "release", "hex", "index", "count", "__class_getitem__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.memoryview";
    rt.short_name = "memoryview";
    rt.method_names = py_methods_235;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.format";
    rf.short_name = "format";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.itemsize";
    rf.short_name = "itemsize";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.shape";
    rf.short_name = "shape";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.strides";
    rf.short_name = "strides";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.suboffsets";
    rf.short_name = "suboffsets";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.readonly";
    rf.short_name = "readonly";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.ndim";
    rf.short_name = "ndim";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.obj";
    rf.short_name = "obj";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.c_contiguous";
    rf.short_name = "c_contiguous";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.f_contiguous";
    rf.short_name = "f_contiguous";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.contiguous";
    rf.short_name = "contiguous";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.nbytes";
    rf.short_name = "nbytes";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.cast";
    rf.short_name = "cast";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.tobytes";
    rf.short_name = "tobytes";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.tolist";
    rf.short_name = "tolist";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.toreadonly";
    rf.short_name = "toreadonly";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.release";
    rf.short_name = "release";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.hex";
    rf.short_name = "hex";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.index";
    rf.short_name = "index";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.count";
    rf.short_name = "count";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.memoryview.__class_getitem__";
    rf.short_name = "__class_getitem__";
    rf.receiver_type = "builtins.memoryview";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.bool";
    rt.short_name = "bool";
    static const char* py_bases_236[] = { "builtins.int", NULL };
    rt.embedded_types = py_bases_236;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_237[] = { "start", "step", "stop", "__hash__", "indices", "__class_getitem__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.slice";
    rt.short_name = "slice";
    rt.method_names = py_methods_237;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.slice.start";
    rf.short_name = "start";
    rf.receiver_type = "builtins.slice";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.slice.step";
    rf.short_name = "step";
    rf.receiver_type = "builtins.slice";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.slice.stop";
    rf.short_name = "stop";
    rf.receiver_type = "builtins.slice";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.slice.__hash__";
    rf.short_name = "__hash__";
    rf.receiver_type = "builtins.slice";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.slice.indices";
    rf.short_name = "indices";
    rf.receiver_type = "builtins.slice";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.slice.__class_getitem__";
    rf.short_name = "__class_getitem__";
    rf.receiver_type = "builtins.slice";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_238[] = { "count", "index", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.tuple";
    rt.short_name = "tuple";
    rt.method_names = py_methods_238;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.tuple.count";
    rf.short_name = "count";
    rf.receiver_type = "builtins.tuple";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.tuple.index";
    rf.short_name = "index";
    rf.receiver_type = "builtins.tuple";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_239[] = { "__new__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.function";
    rt.short_name = "function";
    rt.method_names = py_methods_239;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.function.__new__";
    rf.short_name = "__new__";
    rf.receiver_type = "builtins.function";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_240[] = { "__init__", "copy", "append", "extend", "pop", "index", "count", "insert", "remove", "sort", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.list";
    rt.short_name = "list";
    rt.method_names = py_methods_240;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.list.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.list";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.list.copy";
    rf.short_name = "copy";
    rf.receiver_type = "builtins.list";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.list.append";
    rf.short_name = "append";
    rf.receiver_type = "builtins.list";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.list.extend";
    rf.short_name = "extend";
    rf.receiver_type = "builtins.list";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.list.pop";
    rf.short_name = "pop";
    rf.receiver_type = "builtins.list";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.list.index";
    rf.short_name = "index";
    rf.receiver_type = "builtins.list";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.list.count";
    rf.short_name = "count";
    rf.receiver_type = "builtins.list";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.list.insert";
    rf.short_name = "insert";
    rf.receiver_type = "builtins.list";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.list.remove";
    rf.short_name = "remove";
    rf.receiver_type = "builtins.list";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.list.sort";
    rf.short_name = "sort";
    rf.receiver_type = "builtins.list";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_241[] = { "__init__", "copy", "keys", "values", "items", "fromkeys", "get", "pop", "__or__", "__ror__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.dict";
    rt.short_name = "dict";
    rt.method_names = py_methods_241;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.dict.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.dict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.dict.copy";
    rf.short_name = "copy";
    rf.receiver_type = "builtins.dict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.dict.keys";
    rf.short_name = "keys";
    rf.receiver_type = "builtins.dict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.dict.values";
    rf.short_name = "values";
    rf.receiver_type = "builtins.dict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.dict.items";
    rf.short_name = "items";
    rf.receiver_type = "builtins.dict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.dict.fromkeys";
    rf.short_name = "fromkeys";
    rf.receiver_type = "builtins.dict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.dict.get";
    rf.short_name = "get";
    rf.receiver_type = "builtins.dict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.dict.pop";
    rf.short_name = "pop";
    rf.receiver_type = "builtins.dict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.dict.__or__";
    rf.short_name = "__or__";
    rf.receiver_type = "builtins.dict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.dict.__ror__";
    rf.short_name = "__ror__";
    rf.receiver_type = "builtins.dict";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_242[] = { "__init__", "copy", "fromkeys", "get", "keys", "values", "items", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.frozendict";
    rt.short_name = "frozendict";
    rt.method_names = py_methods_242;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.frozendict.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.frozendict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.frozendict.copy";
    rf.short_name = "copy";
    rf.receiver_type = "builtins.frozendict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.frozendict.fromkeys";
    rf.short_name = "fromkeys";
    rf.receiver_type = "builtins.frozendict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.frozendict.get";
    rf.short_name = "get";
    rf.receiver_type = "builtins.frozendict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.frozendict.keys";
    rf.short_name = "keys";
    rf.receiver_type = "builtins.frozendict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.frozendict.values";
    rf.short_name = "values";
    rf.receiver_type = "builtins.frozendict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.frozendict.items";
    rf.short_name = "items";
    rf.receiver_type = "builtins.frozendict";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_243[] = { "__init__", "add", "copy", "difference", "difference_update", "discard", "intersection", "intersection_update", "isdisjoint", "issubset", "issuperset", "remove", "symmetric_difference", "symmetric_difference_update", "union", "update", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.set";
    rt.short_name = "set";
    rt.method_names = py_methods_243;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.set.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.set";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.set.add";
    rf.short_name = "add";
    rf.receiver_type = "builtins.set";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.set.copy";
    rf.short_name = "copy";
    rf.receiver_type = "builtins.set";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.set.difference";
    rf.short_name = "difference";
    rf.receiver_type = "builtins.set";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.set.difference_update";
    rf.short_name = "difference_update";
    rf.receiver_type = "builtins.set";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.set.discard";
    rf.short_name = "discard";
    rf.receiver_type = "builtins.set";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.set.intersection";
    rf.short_name = "intersection";
    rf.receiver_type = "builtins.set";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.set.intersection_update";
    rf.short_name = "intersection_update";
    rf.receiver_type = "builtins.set";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.set.isdisjoint";
    rf.short_name = "isdisjoint";
    rf.receiver_type = "builtins.set";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.set.issubset";
    rf.short_name = "issubset";
    rf.receiver_type = "builtins.set";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.set.issuperset";
    rf.short_name = "issuperset";
    rf.receiver_type = "builtins.set";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.set.remove";
    rf.short_name = "remove";
    rf.receiver_type = "builtins.set";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.set.symmetric_difference";
    rf.short_name = "symmetric_difference";
    rf.receiver_type = "builtins.set";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.set.symmetric_difference_update";
    rf.short_name = "symmetric_difference_update";
    rf.receiver_type = "builtins.set";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.set.union";
    rf.short_name = "union";
    rf.receiver_type = "builtins.set";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.set.update";
    rf.short_name = "update";
    rf.receiver_type = "builtins.set";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_244[] = { "copy", "difference", "intersection", "isdisjoint", "issubset", "issuperset", "symmetric_difference", "union", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.frozenset";
    rt.short_name = "frozenset";
    rt.method_names = py_methods_244;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.frozenset.copy";
    rf.short_name = "copy";
    rf.receiver_type = "builtins.frozenset";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.frozenset.difference";
    rf.short_name = "difference";
    rf.receiver_type = "builtins.frozenset";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.frozenset.intersection";
    rf.short_name = "intersection";
    rf.receiver_type = "builtins.frozenset";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.frozenset.isdisjoint";
    rf.short_name = "isdisjoint";
    rf.receiver_type = "builtins.frozenset";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.frozenset.issubset";
    rf.short_name = "issubset";
    rf.receiver_type = "builtins.frozenset";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.frozenset.issuperset";
    rf.short_name = "issuperset";
    rf.receiver_type = "builtins.frozenset";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.frozenset.symmetric_difference";
    rf.short_name = "symmetric_difference";
    rf.receiver_type = "builtins.frozenset";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.frozenset.union";
    rf.short_name = "union";
    rf.receiver_type = "builtins.frozenset";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.enumerate";
    rt.short_name = "enumerate";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_245[] = { "start", "stop", "step", "count", "index", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.range";
    rt.short_name = "range";
    rt.method_names = py_methods_245;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.range.start";
    rf.short_name = "start";
    rf.receiver_type = "builtins.range";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.range.stop";
    rf.short_name = "stop";
    rf.receiver_type = "builtins.range";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.range.step";
    rf.short_name = "step";
    rf.receiver_type = "builtins.range";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.range.count";
    rf.short_name = "count";
    rf.receiver_type = "builtins.range";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.range.index";
    rf.short_name = "index";
    rf.receiver_type = "builtins.range";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_246[] = { "__init__", "getter", "setter", "deleter", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.property";
    rt.short_name = "property";
    rt.method_names = py_methods_246;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.property.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.property";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.property.getter";
    rf.short_name = "getter";
    rf.receiver_type = "builtins.property";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.property.setter";
    rf.short_name = "setter";
    rf.receiver_type = "builtins.property";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.property.deleter";
    rf.short_name = "deleter";
    rf.receiver_type = "builtins.property";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins._SupportsSynchronousAnext";
    rt.short_name = "_SupportsSynchronousAnext";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.filter";
    rt.short_name = "filter";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins._GetItemIterable";
    rt.short_name = "_GetItemIterable";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_247[] = { "__new__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.map";
    rt.short_name = "map";
    rt.method_names = py_methods_247;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.map.__new__";
    rf.short_name = "__new__";
    rf.receiver_type = "builtins.map";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins._SupportsWriteAndFlush";
    rt.short_name = "_SupportsWriteAndFlush";
    static const char* py_bases_248[] = { "builtins.SupportsFlush", NULL };
    rt.embedded_types = py_bases_248;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins._SupportsPow2";
    rt.short_name = "_SupportsPow2";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins._SupportsPow3NoneOnly";
    rt.short_name = "_SupportsPow3NoneOnly";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins._SupportsPow3";
    rt.short_name = "_SupportsPow3";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.reversed";
    rt.short_name = "reversed";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins._SupportsRound1";
    rt.short_name = "_SupportsRound1";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins._SupportsRound2";
    rt.short_name = "_SupportsRound2";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.sentinel";
    rt.short_name = "sentinel";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins._SupportsSumWithNoDefaultGiven";
    rt.short_name = "_SupportsSumWithNoDefaultGiven";
    static const char* py_bases_249[] = { "builtins.Protocol", NULL };
    rt.embedded_types = py_bases_249;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.zip";
    rt.short_name = "zip";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_250[] = { "__init__", "with_traceback", "add_note", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.BaseException";
    rt.short_name = "BaseException";
    rt.method_names = py_methods_250;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.BaseException.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.BaseException";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.BaseException.with_traceback";
    rf.short_name = "with_traceback";
    rf.receiver_type = "builtins.BaseException";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.BaseException.add_note";
    rf.short_name = "add_note";
    rf.receiver_type = "builtins.BaseException";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.GeneratorExit";
    rt.short_name = "GeneratorExit";
    static const char* py_bases_251[] = { "builtins.BaseException", NULL };
    rt.embedded_types = py_bases_251;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.KeyboardInterrupt";
    rt.short_name = "KeyboardInterrupt";
    static const char* py_bases_252[] = { "builtins.BaseException", NULL };
    rt.embedded_types = py_bases_252;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.SystemExit";
    rt.short_name = "SystemExit";
    static const char* py_bases_253[] = { "builtins.BaseException", NULL };
    rt.embedded_types = py_bases_253;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.Exception";
    rt.short_name = "Exception";
    static const char* py_bases_254[] = { "builtins.BaseException", NULL };
    rt.embedded_types = py_bases_254;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.StopIteration";
    rt.short_name = "StopIteration";
    static const char* py_bases_255[] = { "builtins.Exception", NULL };
    rt.embedded_types = py_bases_255;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.OSError";
    rt.short_name = "OSError";
    static const char* py_bases_256[] = { "builtins.Exception", NULL };
    rt.embedded_types = py_bases_256;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.ArithmeticError";
    rt.short_name = "ArithmeticError";
    static const char* py_bases_257[] = { "builtins.Exception", NULL };
    rt.embedded_types = py_bases_257;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.AssertionError";
    rt.short_name = "AssertionError";
    static const char* py_bases_258[] = { "builtins.Exception", NULL };
    rt.embedded_types = py_bases_258;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_259[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.AttributeError";
    rt.short_name = "AttributeError";
    rt.method_names = py_methods_259;
    static const char* py_bases_260[] = { "builtins.Exception", NULL };
    rt.embedded_types = py_bases_260;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.AttributeError.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.AttributeError";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.BufferError";
    rt.short_name = "BufferError";
    static const char* py_bases_261[] = { "builtins.Exception", NULL };
    rt.embedded_types = py_bases_261;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.EOFError";
    rt.short_name = "EOFError";
    static const char* py_bases_262[] = { "builtins.Exception", NULL };
    rt.embedded_types = py_bases_262;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_263[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.ImportError";
    rt.short_name = "ImportError";
    rt.method_names = py_methods_263;
    static const char* py_bases_264[] = { "builtins.Exception", NULL };
    rt.embedded_types = py_bases_264;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.ImportError.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.ImportError";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.ImportCycleError";
    rt.short_name = "ImportCycleError";
    static const char* py_bases_265[] = { "builtins.ImportError", NULL };
    rt.embedded_types = py_bases_265;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.LookupError";
    rt.short_name = "LookupError";
    static const char* py_bases_266[] = { "builtins.Exception", NULL };
    rt.embedded_types = py_bases_266;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.MemoryError";
    rt.short_name = "MemoryError";
    static const char* py_bases_267[] = { "builtins.Exception", NULL };
    rt.embedded_types = py_bases_267;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_268[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.NameError";
    rt.short_name = "NameError";
    rt.method_names = py_methods_268;
    static const char* py_bases_269[] = { "builtins.Exception", NULL };
    rt.embedded_types = py_bases_269;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.NameError.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.NameError";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.ReferenceError";
    rt.short_name = "ReferenceError";
    static const char* py_bases_270[] = { "builtins.Exception", NULL };
    rt.embedded_types = py_bases_270;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.RuntimeError";
    rt.short_name = "RuntimeError";
    static const char* py_bases_271[] = { "builtins.Exception", NULL };
    rt.embedded_types = py_bases_271;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.StopAsyncIteration";
    rt.short_name = "StopAsyncIteration";
    static const char* py_bases_272[] = { "builtins.Exception", NULL };
    rt.embedded_types = py_bases_272;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_273[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.SyntaxError";
    rt.short_name = "SyntaxError";
    rt.method_names = py_methods_273;
    static const char* py_bases_274[] = { "builtins.Exception", NULL };
    rt.embedded_types = py_bases_274;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.SyntaxError.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.SyntaxError";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.SystemError";
    rt.short_name = "SystemError";
    static const char* py_bases_275[] = { "builtins.Exception", NULL };
    rt.embedded_types = py_bases_275;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.TypeError";
    rt.short_name = "TypeError";
    static const char* py_bases_276[] = { "builtins.Exception", NULL };
    rt.embedded_types = py_bases_276;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.ValueError";
    rt.short_name = "ValueError";
    static const char* py_bases_277[] = { "builtins.Exception", NULL };
    rt.embedded_types = py_bases_277;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.FloatingPointError";
    rt.short_name = "FloatingPointError";
    static const char* py_bases_278[] = { "builtins.ArithmeticError", NULL };
    rt.embedded_types = py_bases_278;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.OverflowError";
    rt.short_name = "OverflowError";
    static const char* py_bases_279[] = { "builtins.ArithmeticError", NULL };
    rt.embedded_types = py_bases_279;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.ZeroDivisionError";
    rt.short_name = "ZeroDivisionError";
    static const char* py_bases_280[] = { "builtins.ArithmeticError", NULL };
    rt.embedded_types = py_bases_280;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.ModuleNotFoundError";
    rt.short_name = "ModuleNotFoundError";
    static const char* py_bases_281[] = { "builtins.ImportError", NULL };
    rt.embedded_types = py_bases_281;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.IndexError";
    rt.short_name = "IndexError";
    static const char* py_bases_282[] = { "builtins.LookupError", NULL };
    rt.embedded_types = py_bases_282;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.KeyError";
    rt.short_name = "KeyError";
    static const char* py_bases_283[] = { "builtins.LookupError", NULL };
    rt.embedded_types = py_bases_283;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.UnboundLocalError";
    rt.short_name = "UnboundLocalError";
    static const char* py_bases_284[] = { "builtins.NameError", NULL };
    rt.embedded_types = py_bases_284;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.BlockingIOError";
    rt.short_name = "BlockingIOError";
    static const char* py_bases_285[] = { "builtins.OSError", NULL };
    rt.embedded_types = py_bases_285;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.ChildProcessError";
    rt.short_name = "ChildProcessError";
    static const char* py_bases_286[] = { "builtins.OSError", NULL };
    rt.embedded_types = py_bases_286;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.ConnectionError";
    rt.short_name = "ConnectionError";
    static const char* py_bases_287[] = { "builtins.OSError", NULL };
    rt.embedded_types = py_bases_287;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.BrokenPipeError";
    rt.short_name = "BrokenPipeError";
    static const char* py_bases_288[] = { "builtins.ConnectionError", NULL };
    rt.embedded_types = py_bases_288;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.ConnectionAbortedError";
    rt.short_name = "ConnectionAbortedError";
    static const char* py_bases_289[] = { "builtins.ConnectionError", NULL };
    rt.embedded_types = py_bases_289;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.ConnectionRefusedError";
    rt.short_name = "ConnectionRefusedError";
    static const char* py_bases_290[] = { "builtins.ConnectionError", NULL };
    rt.embedded_types = py_bases_290;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.ConnectionResetError";
    rt.short_name = "ConnectionResetError";
    static const char* py_bases_291[] = { "builtins.ConnectionError", NULL };
    rt.embedded_types = py_bases_291;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.FileExistsError";
    rt.short_name = "FileExistsError";
    static const char* py_bases_292[] = { "builtins.OSError", NULL };
    rt.embedded_types = py_bases_292;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.FileNotFoundError";
    rt.short_name = "FileNotFoundError";
    static const char* py_bases_293[] = { "builtins.OSError", NULL };
    rt.embedded_types = py_bases_293;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.InterruptedError";
    rt.short_name = "InterruptedError";
    static const char* py_bases_294[] = { "builtins.OSError", NULL };
    rt.embedded_types = py_bases_294;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.IsADirectoryError";
    rt.short_name = "IsADirectoryError";
    static const char* py_bases_295[] = { "builtins.OSError", NULL };
    rt.embedded_types = py_bases_295;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.NotADirectoryError";
    rt.short_name = "NotADirectoryError";
    static const char* py_bases_296[] = { "builtins.OSError", NULL };
    rt.embedded_types = py_bases_296;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.PermissionError";
    rt.short_name = "PermissionError";
    static const char* py_bases_297[] = { "builtins.OSError", NULL };
    rt.embedded_types = py_bases_297;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.ProcessLookupError";
    rt.short_name = "ProcessLookupError";
    static const char* py_bases_298[] = { "builtins.OSError", NULL };
    rt.embedded_types = py_bases_298;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.TimeoutError";
    rt.short_name = "TimeoutError";
    static const char* py_bases_299[] = { "builtins.OSError", NULL };
    rt.embedded_types = py_bases_299;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.NotImplementedError";
    rt.short_name = "NotImplementedError";
    static const char* py_bases_300[] = { "builtins.RuntimeError", NULL };
    rt.embedded_types = py_bases_300;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.RecursionError";
    rt.short_name = "RecursionError";
    static const char* py_bases_301[] = { "builtins.RuntimeError", NULL };
    rt.embedded_types = py_bases_301;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.IndentationError";
    rt.short_name = "IndentationError";
    static const char* py_bases_302[] = { "builtins.SyntaxError", NULL };
    rt.embedded_types = py_bases_302;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.TabError";
    rt.short_name = "TabError";
    static const char* py_bases_303[] = { "builtins.IndentationError", NULL };
    rt.embedded_types = py_bases_303;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.UnicodeError";
    rt.short_name = "UnicodeError";
    static const char* py_bases_304[] = { "builtins.ValueError", NULL };
    rt.embedded_types = py_bases_304;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_305[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.UnicodeDecodeError";
    rt.short_name = "UnicodeDecodeError";
    rt.method_names = py_methods_305;
    static const char* py_bases_306[] = { "builtins.UnicodeError", NULL };
    rt.embedded_types = py_bases_306;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.UnicodeDecodeError.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.UnicodeDecodeError";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_307[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.UnicodeEncodeError";
    rt.short_name = "UnicodeEncodeError";
    rt.method_names = py_methods_307;
    static const char* py_bases_308[] = { "builtins.UnicodeError", NULL };
    rt.embedded_types = py_bases_308;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.UnicodeEncodeError.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.UnicodeEncodeError";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_309[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.UnicodeTranslateError";
    rt.short_name = "UnicodeTranslateError";
    rt.method_names = py_methods_309;
    static const char* py_bases_310[] = { "builtins.UnicodeError", NULL };
    rt.embedded_types = py_bases_310;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.UnicodeTranslateError.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.UnicodeTranslateError";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.Warning";
    rt.short_name = "Warning";
    static const char* py_bases_311[] = { "builtins.Exception", NULL };
    rt.embedded_types = py_bases_311;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.UserWarning";
    rt.short_name = "UserWarning";
    static const char* py_bases_312[] = { "builtins.Warning", NULL };
    rt.embedded_types = py_bases_312;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.DeprecationWarning";
    rt.short_name = "DeprecationWarning";
    static const char* py_bases_313[] = { "builtins.Warning", NULL };
    rt.embedded_types = py_bases_313;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.SyntaxWarning";
    rt.short_name = "SyntaxWarning";
    static const char* py_bases_314[] = { "builtins.Warning", NULL };
    rt.embedded_types = py_bases_314;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.RuntimeWarning";
    rt.short_name = "RuntimeWarning";
    static const char* py_bases_315[] = { "builtins.Warning", NULL };
    rt.embedded_types = py_bases_315;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.FutureWarning";
    rt.short_name = "FutureWarning";
    static const char* py_bases_316[] = { "builtins.Warning", NULL };
    rt.embedded_types = py_bases_316;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.PendingDeprecationWarning";
    rt.short_name = "PendingDeprecationWarning";
    static const char* py_bases_317[] = { "builtins.Warning", NULL };
    rt.embedded_types = py_bases_317;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.ImportWarning";
    rt.short_name = "ImportWarning";
    static const char* py_bases_318[] = { "builtins.Warning", NULL };
    rt.embedded_types = py_bases_318;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.UnicodeWarning";
    rt.short_name = "UnicodeWarning";
    static const char* py_bases_319[] = { "builtins.Warning", NULL };
    rt.embedded_types = py_bases_319;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.BytesWarning";
    rt.short_name = "BytesWarning";
    static const char* py_bases_320[] = { "builtins.Warning", NULL };
    rt.embedded_types = py_bases_320;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.ResourceWarning";
    rt.short_name = "ResourceWarning";
    static const char* py_bases_321[] = { "builtins.Warning", NULL };
    rt.embedded_types = py_bases_321;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.EncodingWarning";
    rt.short_name = "EncodingWarning";
    static const char* py_bases_322[] = { "builtins.Warning", NULL };
    rt.embedded_types = py_bases_322;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_323[] = { "__init__", "message", "exceptions", "subgroup", "split", "derive", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.BaseExceptionGroup";
    rt.short_name = "BaseExceptionGroup";
    rt.method_names = py_methods_323;
    static const char* py_bases_324[] = { "builtins.BaseException", NULL };
    rt.embedded_types = py_bases_324;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.BaseExceptionGroup.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.BaseExceptionGroup";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.BaseExceptionGroup.message";
    rf.short_name = "message";
    rf.receiver_type = "builtins.BaseExceptionGroup";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.BaseExceptionGroup.exceptions";
    rf.short_name = "exceptions";
    rf.receiver_type = "builtins.BaseExceptionGroup";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.BaseExceptionGroup.subgroup";
    rf.short_name = "subgroup";
    rf.receiver_type = "builtins.BaseExceptionGroup";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.BaseExceptionGroup.split";
    rf.short_name = "split";
    rf.receiver_type = "builtins.BaseExceptionGroup";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.BaseExceptionGroup.derive";
    rf.short_name = "derive";
    rf.receiver_type = "builtins.BaseExceptionGroup";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_325[] = { "__init__", "exceptions", "subgroup", "split", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.ExceptionGroup";
    rt.short_name = "ExceptionGroup";
    rt.method_names = py_methods_325;
    static const char* py_bases_326[] = { "builtins.Exception", NULL };
    rt.embedded_types = py_bases_326;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.ExceptionGroup.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "builtins.ExceptionGroup";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.ExceptionGroup.exceptions";
    rf.short_name = "exceptions";
    rf.receiver_type = "builtins.ExceptionGroup";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.ExceptionGroup.subgroup";
    rf.short_name = "subgroup";
    rf.receiver_type = "builtins.ExceptionGroup";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.ExceptionGroup.split";
    rf.short_name = "split";
    rf.receiver_type = "builtins.ExceptionGroup";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "builtins.PythonFinalizationError";
    rt.short_name = "PythonFinalizationError";
    static const char* py_bases_327[] = { "builtins.RuntimeError", NULL };
    rt.embedded_types = py_bases_327;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.abs";
    rf.short_name = "abs";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.all";
    rf.short_name = "all";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.any";
    rf.short_name = "any";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.ascii";
    rf.short_name = "ascii";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.bin";
    rf.short_name = "bin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.breakpoint";
    rf.short_name = "breakpoint";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.callable";
    rf.short_name = "callable";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.chr";
    rf.short_name = "chr";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.aiter";
    rf.short_name = "aiter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.anext";
    rf.short_name = "anext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.compile";
    rf.short_name = "compile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.delattr";
    rf.short_name = "delattr";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.dir";
    rf.short_name = "dir";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.divmod";
    rf.short_name = "divmod";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.eval";
    rf.short_name = "eval";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.exec";
    rf.short_name = "exec";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.format";
    rf.short_name = "format";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.getattr";
    rf.short_name = "getattr";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.globals";
    rf.short_name = "globals";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.hasattr";
    rf.short_name = "hasattr";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.hash";
    rf.short_name = "hash";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.hex";
    rf.short_name = "hex";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.id";
    rf.short_name = "id";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.input";
    rf.short_name = "input";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.iter";
    rf.short_name = "iter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.isinstance";
    rf.short_name = "isinstance";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.issubclass";
    rf.short_name = "issubclass";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.len";
    rf.short_name = "len";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.locals";
    rf.short_name = "locals";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.max";
    rf.short_name = "max";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.min";
    rf.short_name = "min";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.next";
    rf.short_name = "next";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.oct";
    rf.short_name = "oct";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.open";
    rf.short_name = "open";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.ord";
    rf.short_name = "ord";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.print";
    rf.short_name = "print";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.pow";
    rf.short_name = "pow";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.repr";
    rf.short_name = "repr";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.round";
    rf.short_name = "round";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.setattr";
    rf.short_name = "setattr";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.sorted";
    rf.short_name = "sorted";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.sum";
    rf.short_name = "sum";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "builtins.vars";
    rf.short_name = "vars";
    cbm_registry_add_func(reg, rf);

    /* ===== module: collections ===== */
    static const char* py_methods_328[] = { "__init__", "copy", "fromkeys", "get", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "collections.UserDict";
    rt.short_name = "UserDict";
    rt.method_names = py_methods_328;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserDict.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "collections.UserDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserDict.copy";
    rf.short_name = "copy";
    rf.receiver_type = "collections.UserDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserDict.fromkeys";
    rf.short_name = "fromkeys";
    rf.receiver_type = "collections.UserDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserDict.get";
    rf.short_name = "get";
    rf.receiver_type = "collections.UserDict";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_329[] = { "__init__", "append", "insert", "pop", "remove", "copy", "count", "index", "sort", "extend", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "collections.UserList";
    rt.short_name = "UserList";
    rt.method_names = py_methods_329;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserList.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "collections.UserList";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserList.append";
    rf.short_name = "append";
    rf.receiver_type = "collections.UserList";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserList.insert";
    rf.short_name = "insert";
    rf.receiver_type = "collections.UserList";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserList.pop";
    rf.short_name = "pop";
    rf.receiver_type = "collections.UserList";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserList.remove";
    rf.short_name = "remove";
    rf.receiver_type = "collections.UserList";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserList.copy";
    rf.short_name = "copy";
    rf.receiver_type = "collections.UserList";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserList.count";
    rf.short_name = "count";
    rf.receiver_type = "collections.UserList";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserList.index";
    rf.short_name = "index";
    rf.receiver_type = "collections.UserList";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserList.sort";
    rf.short_name = "sort";
    rf.receiver_type = "collections.UserList";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserList.extend";
    rf.short_name = "extend";
    rf.receiver_type = "collections.UserList";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_330[] = { "__init__", "capitalize", "casefold", "center", "count", "encode", "endswith", "expandtabs", "find", "format", "format_map", "index", "isalpha", "isalnum", "isdecimal", "isdigit", "isidentifier", "islower", "isnumeric", "isprintable", "isspace", "istitle", "isupper", "isascii", "join", "ljust", "lower", "lstrip", "partition", "removeprefix", "removesuffix", "replace", "rfind", "rindex", "rjust", "rpartition", "rstrip", "split", "rsplit", "splitlines", "startswith", "strip", "swapcase", "title", "translate", "upper", "zfill", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "collections.UserString";
    rt.short_name = "UserString";
    rt.method_names = py_methods_330;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.capitalize";
    rf.short_name = "capitalize";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.casefold";
    rf.short_name = "casefold";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.center";
    rf.short_name = "center";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.count";
    rf.short_name = "count";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.encode";
    rf.short_name = "encode";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.endswith";
    rf.short_name = "endswith";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.expandtabs";
    rf.short_name = "expandtabs";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.find";
    rf.short_name = "find";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.format";
    rf.short_name = "format";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.format_map";
    rf.short_name = "format_map";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.index";
    rf.short_name = "index";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.isalpha";
    rf.short_name = "isalpha";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.isalnum";
    rf.short_name = "isalnum";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.isdecimal";
    rf.short_name = "isdecimal";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.isdigit";
    rf.short_name = "isdigit";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.isidentifier";
    rf.short_name = "isidentifier";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.islower";
    rf.short_name = "islower";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.isnumeric";
    rf.short_name = "isnumeric";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.isprintable";
    rf.short_name = "isprintable";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.isspace";
    rf.short_name = "isspace";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.istitle";
    rf.short_name = "istitle";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.isupper";
    rf.short_name = "isupper";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.isascii";
    rf.short_name = "isascii";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.join";
    rf.short_name = "join";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.ljust";
    rf.short_name = "ljust";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.lower";
    rf.short_name = "lower";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.lstrip";
    rf.short_name = "lstrip";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.partition";
    rf.short_name = "partition";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.removeprefix";
    rf.short_name = "removeprefix";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.removesuffix";
    rf.short_name = "removesuffix";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.replace";
    rf.short_name = "replace";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.rfind";
    rf.short_name = "rfind";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.rindex";
    rf.short_name = "rindex";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.rjust";
    rf.short_name = "rjust";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.rpartition";
    rf.short_name = "rpartition";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.rstrip";
    rf.short_name = "rstrip";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.split";
    rf.short_name = "split";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.rsplit";
    rf.short_name = "rsplit";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.splitlines";
    rf.short_name = "splitlines";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.startswith";
    rf.short_name = "startswith";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.strip";
    rf.short_name = "strip";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.swapcase";
    rf.short_name = "swapcase";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.title";
    rf.short_name = "title";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.translate";
    rf.short_name = "translate";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.upper";
    rf.short_name = "upper";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.UserString.zfill";
    rf.short_name = "zfill";
    rf.receiver_type = "collections.UserString";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_331[] = { "maxlen", "__init__", "append", "appendleft", "copy", "count", "extend", "extendleft", "insert", "index", "pop", "popleft", "remove", "rotate", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "collections.deque";
    rt.short_name = "deque";
    rt.method_names = py_methods_331;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.deque.maxlen";
    rf.short_name = "maxlen";
    rf.receiver_type = "collections.deque";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.deque.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "collections.deque";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.deque.append";
    rf.short_name = "append";
    rf.receiver_type = "collections.deque";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.deque.appendleft";
    rf.short_name = "appendleft";
    rf.receiver_type = "collections.deque";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.deque.copy";
    rf.short_name = "copy";
    rf.receiver_type = "collections.deque";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.deque.count";
    rf.short_name = "count";
    rf.receiver_type = "collections.deque";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.deque.extend";
    rf.short_name = "extend";
    rf.receiver_type = "collections.deque";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.deque.extendleft";
    rf.short_name = "extendleft";
    rf.receiver_type = "collections.deque";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.deque.insert";
    rf.short_name = "insert";
    rf.receiver_type = "collections.deque";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.deque.index";
    rf.short_name = "index";
    rf.receiver_type = "collections.deque";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.deque.pop";
    rf.short_name = "pop";
    rf.receiver_type = "collections.deque";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.deque.popleft";
    rf.short_name = "popleft";
    rf.receiver_type = "collections.deque";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.deque.remove";
    rf.short_name = "remove";
    rf.receiver_type = "collections.deque";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.deque.rotate";
    rf.short_name = "rotate";
    rf.receiver_type = "collections.deque";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_332[] = { "__init__", "copy", "elements", "most_common", "fromkeys", "subtract", "update", "total", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "collections.Counter";
    rt.short_name = "Counter";
    rt.method_names = py_methods_332;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.Counter.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "collections.Counter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.Counter.copy";
    rf.short_name = "copy";
    rf.receiver_type = "collections.Counter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.Counter.elements";
    rf.short_name = "elements";
    rf.receiver_type = "collections.Counter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.Counter.most_common";
    rf.short_name = "most_common";
    rf.receiver_type = "collections.Counter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.Counter.fromkeys";
    rf.short_name = "fromkeys";
    rf.receiver_type = "collections.Counter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.Counter.subtract";
    rf.short_name = "subtract";
    rf.receiver_type = "collections.Counter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.Counter.update";
    rf.short_name = "update";
    rf.receiver_type = "collections.Counter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.Counter.total";
    rf.short_name = "total";
    rf.receiver_type = "collections.Counter";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "collections._OrderedDictKeysView";
    rt.short_name = "_OrderedDictKeysView";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "collections._OrderedDictItemsView";
    rt.short_name = "_OrderedDictItemsView";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "collections._OrderedDictValuesView";
    rt.short_name = "_OrderedDictValuesView";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "collections._odict_keys";
    rt.short_name = "_odict_keys";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "collections._odict_items";
    rt.short_name = "_odict_items";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "collections._odict_values";
    rt.short_name = "_odict_values";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_333[] = { "popitem", "move_to_end", "copy", "keys", "items", "values", "fromkeys", "setdefault", "pop", "__or__", "__ror__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "collections.OrderedDict";
    rt.short_name = "OrderedDict";
    rt.method_names = py_methods_333;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.OrderedDict.popitem";
    rf.short_name = "popitem";
    rf.receiver_type = "collections.OrderedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.OrderedDict.move_to_end";
    rf.short_name = "move_to_end";
    rf.receiver_type = "collections.OrderedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.OrderedDict.copy";
    rf.short_name = "copy";
    rf.receiver_type = "collections.OrderedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.OrderedDict.keys";
    rf.short_name = "keys";
    rf.receiver_type = "collections.OrderedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.OrderedDict.items";
    rf.short_name = "items";
    rf.receiver_type = "collections.OrderedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.OrderedDict.values";
    rf.short_name = "values";
    rf.receiver_type = "collections.OrderedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.OrderedDict.fromkeys";
    rf.short_name = "fromkeys";
    rf.receiver_type = "collections.OrderedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.OrderedDict.setdefault";
    rf.short_name = "setdefault";
    rf.receiver_type = "collections.OrderedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.OrderedDict.pop";
    rf.short_name = "pop";
    rf.receiver_type = "collections.OrderedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.OrderedDict.__or__";
    rf.short_name = "__or__";
    rf.receiver_type = "collections.OrderedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.OrderedDict.__ror__";
    rf.short_name = "__ror__";
    rf.receiver_type = "collections.OrderedDict";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_334[] = { "__init__", "copy", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "collections.defaultdict";
    rt.short_name = "defaultdict";
    rt.method_names = py_methods_334;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.defaultdict.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "collections.defaultdict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.defaultdict.copy";
    rf.short_name = "copy";
    rf.receiver_type = "collections.defaultdict";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_335[] = { "__init__", "new_child", "parents", "get", "setdefault", "pop", "copy", "fromkeys", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "collections.ChainMap";
    rt.short_name = "ChainMap";
    rt.method_names = py_methods_335;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.ChainMap.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "collections.ChainMap";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.ChainMap.new_child";
    rf.short_name = "new_child";
    rf.receiver_type = "collections.ChainMap";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.ChainMap.parents";
    rf.short_name = "parents";
    rf.receiver_type = "collections.ChainMap";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.ChainMap.get";
    rf.short_name = "get";
    rf.receiver_type = "collections.ChainMap";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.ChainMap.setdefault";
    rf.short_name = "setdefault";
    rf.receiver_type = "collections.ChainMap";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.ChainMap.pop";
    rf.short_name = "pop";
    rf.receiver_type = "collections.ChainMap";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.ChainMap.copy";
    rf.short_name = "copy";
    rf.receiver_type = "collections.ChainMap";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.ChainMap.fromkeys";
    rf.short_name = "fromkeys";
    rf.receiver_type = "collections.ChainMap";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.namedtuple";
    rf.short_name = "namedtuple";
    cbm_registry_add_func(reg, rf);

    /* ===== module: collections.abc ===== */
    static const char* py_methods_336[] = { "isdisjoint", "mapping", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "collections.abc.dict_keys";
    rt.short_name = "dict_keys";
    rt.method_names = py_methods_336;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.abc.dict_keys.isdisjoint";
    rf.short_name = "isdisjoint";
    rf.receiver_type = "collections.abc.dict_keys";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.abc.dict_keys.mapping";
    rf.short_name = "mapping";
    rf.receiver_type = "collections.abc.dict_keys";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_337[] = { "mapping", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "collections.abc.dict_values";
    rt.short_name = "dict_values";
    rt.method_names = py_methods_337;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.abc.dict_values.mapping";
    rf.short_name = "mapping";
    rf.receiver_type = "collections.abc.dict_values";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_338[] = { "isdisjoint", "mapping", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "collections.abc.dict_items";
    rt.short_name = "dict_items";
    rt.method_names = py_methods_338;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.abc.dict_items.isdisjoint";
    rf.short_name = "isdisjoint";
    rf.receiver_type = "collections.abc.dict_items";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "collections.abc.dict_items.mapping";
    rf.short_name = "mapping";
    rf.receiver_type = "collections.abc.dict_items";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "collections.abc.Buffer";
    rt.short_name = "Buffer";
    static const char* py_bases_339[] = { "_collections_abc.Protocol", NULL };
    rt.embedded_types = py_bases_339;
    cbm_registry_add_type(reg, rt);

    /* ===== module: concurrent.futures._base ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures._base.Error";
    rt.short_name = "Error";
    static const char* py_bases_340[] = { "concurrent.futures._base.Exception", NULL };
    rt.embedded_types = py_bases_340;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures._base.CancelledError";
    rt.short_name = "CancelledError";
    static const char* py_bases_341[] = { "concurrent.futures._base.Error", NULL };
    rt.embedded_types = py_bases_341;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures._base.TimeoutError";
    rt.short_name = "TimeoutError";
    static const char* py_bases_342[] = { "concurrent.futures._base.Error", NULL };
    rt.embedded_types = py_bases_342;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures._base.InvalidStateError";
    rt.short_name = "InvalidStateError";
    static const char* py_bases_343[] = { "concurrent.futures._base.Error", NULL };
    rt.embedded_types = py_bases_343;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures._base.BrokenExecutor";
    rt.short_name = "BrokenExecutor";
    static const char* py_bases_344[] = { "concurrent.futures._base.RuntimeError", NULL };
    rt.embedded_types = py_bases_344;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_345[] = { "cancel", "cancelled", "running", "done", "add_done_callback", "result", "set_running_or_notify_cancel", "set_result", "exception", "set_exception", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures._base.Future";
    rt.short_name = "Future";
    rt.method_names = py_methods_345;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base.Future.cancel";
    rf.short_name = "cancel";
    rf.receiver_type = "concurrent.futures._base.Future";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base.Future.cancelled";
    rf.short_name = "cancelled";
    rf.receiver_type = "concurrent.futures._base.Future";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base.Future.running";
    rf.short_name = "running";
    rf.receiver_type = "concurrent.futures._base.Future";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base.Future.done";
    rf.short_name = "done";
    rf.receiver_type = "concurrent.futures._base.Future";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base.Future.add_done_callback";
    rf.short_name = "add_done_callback";
    rf.receiver_type = "concurrent.futures._base.Future";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base.Future.result";
    rf.short_name = "result";
    rf.receiver_type = "concurrent.futures._base.Future";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base.Future.set_running_or_notify_cancel";
    rf.short_name = "set_running_or_notify_cancel";
    rf.receiver_type = "concurrent.futures._base.Future";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base.Future.set_result";
    rf.short_name = "set_result";
    rf.receiver_type = "concurrent.futures._base.Future";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base.Future.exception";
    rf.short_name = "exception";
    rf.receiver_type = "concurrent.futures._base.Future";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base.Future.set_exception";
    rf.short_name = "set_exception";
    rf.receiver_type = "concurrent.futures._base.Future";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_346[] = { "submit", "map", "shutdown", "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures._base.Executor";
    rt.short_name = "Executor";
    rt.method_names = py_methods_346;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base.Executor.submit";
    rf.short_name = "submit";
    rf.receiver_type = "concurrent.futures._base.Executor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base.Executor.map";
    rf.short_name = "map";
    rf.receiver_type = "concurrent.futures._base.Executor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base.Executor.shutdown";
    rf.short_name = "shutdown";
    rf.receiver_type = "concurrent.futures._base.Executor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base.Executor.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "concurrent.futures._base.Executor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base.Executor.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "concurrent.futures._base.Executor";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_347[] = { "result", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures._base._AsCompletedFuture";
    rt.short_name = "_AsCompletedFuture";
    rt.method_names = py_methods_347;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base._AsCompletedFuture.result";
    rf.short_name = "result";
    rf.receiver_type = "concurrent.futures._base._AsCompletedFuture";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures._base.DoneAndNotDoneFutures";
    rt.short_name = "DoneAndNotDoneFutures";
    static const char* py_bases_348[] = { "concurrent.futures._base.NamedTuple", NULL };
    rt.embedded_types = py_bases_348;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_349[] = { "add_result", "add_exception", "add_cancelled", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures._base._Waiter";
    rt.short_name = "_Waiter";
    rt.method_names = py_methods_349;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base._Waiter.add_result";
    rf.short_name = "add_result";
    rf.receiver_type = "concurrent.futures._base._Waiter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base._Waiter.add_exception";
    rf.short_name = "add_exception";
    rf.receiver_type = "concurrent.futures._base._Waiter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base._Waiter.add_cancelled";
    rf.short_name = "add_cancelled";
    rf.receiver_type = "concurrent.futures._base._Waiter";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures._base._AsCompletedWaiter";
    rt.short_name = "_AsCompletedWaiter";
    static const char* py_bases_350[] = { "concurrent.futures._base._Waiter", NULL };
    rt.embedded_types = py_bases_350;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures._base._FirstCompletedWaiter";
    rt.short_name = "_FirstCompletedWaiter";
    static const char* py_bases_351[] = { "concurrent.futures._base._Waiter", NULL };
    rt.embedded_types = py_bases_351;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_352[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures._base._AllCompletedWaiter";
    rt.short_name = "_AllCompletedWaiter";
    rt.method_names = py_methods_352;
    static const char* py_bases_353[] = { "concurrent.futures._base._Waiter", NULL };
    rt.embedded_types = py_bases_353;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base._AllCompletedWaiter.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "concurrent.futures._base._AllCompletedWaiter";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_354[] = { "__init__", "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures._base._AcquireFutures";
    rt.short_name = "_AcquireFutures";
    rt.method_names = py_methods_354;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base._AcquireFutures.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "concurrent.futures._base._AcquireFutures";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base._AcquireFutures.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "concurrent.futures._base._AcquireFutures";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base._AcquireFutures.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "concurrent.futures._base._AcquireFutures";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base.as_completed";
    rf.short_name = "as_completed";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures._base.wait";
    rf.short_name = "wait";
    cbm_registry_add_func(reg, rf);

    /* ===== module: concurrent.futures.interpreter ===== */
    static const char* py_methods_355[] = { "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures.interpreter._TaskFunc";
    rt.short_name = "_TaskFunc";
    rt.method_names = py_methods_355;
    static const char* py_bases_356[] = { "concurrent.futures.interpreter.Protocol", NULL };
    rt.embedded_types = py_bases_356;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.interpreter._TaskFunc.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "concurrent.futures.interpreter._TaskFunc";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_357[] = { "prepare", "__init__", "run", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures.interpreter.WorkerContext";
    rt.short_name = "WorkerContext";
    rt.method_names = py_methods_357;
    static const char* py_bases_358[] = { "concurrent.futures.interpreter.ThreadWorkerContext", NULL };
    rt.embedded_types = py_bases_358;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.interpreter.WorkerContext.prepare";
    rf.short_name = "prepare";
    rf.receiver_type = "concurrent.futures.interpreter.WorkerContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.interpreter.WorkerContext.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "concurrent.futures.interpreter.WorkerContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.interpreter.WorkerContext.run";
    rf.short_name = "run";
    rf.receiver_type = "concurrent.futures.interpreter.WorkerContext";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures.interpreter.BrokenInterpreterPool";
    rt.short_name = "BrokenInterpreterPool";
    static const char* py_bases_359[] = { "concurrent.futures.interpreter.BrokenThreadPool", NULL };
    rt.embedded_types = py_bases_359;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_360[] = { "prepare_context", "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures.interpreter.InterpreterPoolExecutor";
    rt.short_name = "InterpreterPoolExecutor";
    rt.method_names = py_methods_360;
    static const char* py_bases_361[] = { "concurrent.futures.interpreter.ThreadPoolExecutor", NULL };
    rt.embedded_types = py_bases_361;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.interpreter.InterpreterPoolExecutor.prepare_context";
    rf.short_name = "prepare_context";
    rf.receiver_type = "concurrent.futures.interpreter.InterpreterPoolExecutor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.interpreter.InterpreterPoolExecutor.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "concurrent.futures.interpreter.InterpreterPoolExecutor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.interpreter.do_call";
    rf.short_name = "do_call";
    cbm_registry_add_func(reg, rf);

    /* ===== module: concurrent.futures.process ===== */
    static const char* py_methods_362[] = { "close", "wakeup", "clear", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures.process._ThreadWakeup";
    rt.short_name = "_ThreadWakeup";
    rt.method_names = py_methods_362;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process._ThreadWakeup.close";
    rf.short_name = "close";
    rf.receiver_type = "concurrent.futures.process._ThreadWakeup";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process._ThreadWakeup.wakeup";
    rf.short_name = "wakeup";
    rf.receiver_type = "concurrent.futures.process._ThreadWakeup";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process._ThreadWakeup.clear";
    rf.short_name = "clear";
    rf.receiver_type = "concurrent.futures.process._ThreadWakeup";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_363[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures.process._RemoteTraceback";
    rt.short_name = "_RemoteTraceback";
    rt.method_names = py_methods_363;
    static const char* py_bases_364[] = { "concurrent.futures.process.Exception", NULL };
    rt.embedded_types = py_bases_364;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process._RemoteTraceback.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "concurrent.futures.process._RemoteTraceback";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_365[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures.process._ExceptionWithTraceback";
    rt.short_name = "_ExceptionWithTraceback";
    rt.method_names = py_methods_365;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process._ExceptionWithTraceback.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "concurrent.futures.process._ExceptionWithTraceback";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_366[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures.process._WorkItem";
    rt.short_name = "_WorkItem";
    rt.method_names = py_methods_366;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process._WorkItem.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "concurrent.futures.process._WorkItem";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_367[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures.process._ResultItem";
    rt.short_name = "_ResultItem";
    rt.method_names = py_methods_367;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process._ResultItem.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "concurrent.futures.process._ResultItem";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_368[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures.process._CallItem";
    rt.short_name = "_CallItem";
    rt.method_names = py_methods_368;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process._CallItem.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "concurrent.futures.process._CallItem";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_369[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures.process._SafeQueue";
    rt.short_name = "_SafeQueue";
    rt.method_names = py_methods_369;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process._SafeQueue.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "concurrent.futures.process._SafeQueue";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_370[] = { "__init__", "run", "add_call_item_to_queue", "wait_result_broken_or_wakeup", "process_result_item", "is_shutting_down", "terminate_broken", "flag_executor_shutting_down", "shutdown_workers", "join_executor_internals", "get_n_children_alive", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures.process._ExecutorManagerThread";
    rt.short_name = "_ExecutorManagerThread";
    rt.method_names = py_methods_370;
    static const char* py_bases_371[] = { "concurrent.futures.process.Thread", NULL };
    rt.embedded_types = py_bases_371;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.run";
    rf.short_name = "run";
    rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.add_call_item_to_queue";
    rf.short_name = "add_call_item_to_queue";
    rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.wait_result_broken_or_wakeup";
    rf.short_name = "wait_result_broken_or_wakeup";
    rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.process_result_item";
    rf.short_name = "process_result_item";
    rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.is_shutting_down";
    rf.short_name = "is_shutting_down";
    rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.terminate_broken";
    rf.short_name = "terminate_broken";
    rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.flag_executor_shutting_down";
    rf.short_name = "flag_executor_shutting_down";
    rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.shutdown_workers";
    rf.short_name = "shutdown_workers";
    rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.join_executor_internals";
    rf.short_name = "join_executor_internals";
    rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process._ExecutorManagerThread.get_n_children_alive";
    rf.short_name = "get_n_children_alive";
    rf.receiver_type = "concurrent.futures.process._ExecutorManagerThread";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures.process.BrokenProcessPool";
    rt.short_name = "BrokenProcessPool";
    static const char* py_bases_372[] = { "concurrent.futures.process.BrokenExecutor", NULL };
    rt.embedded_types = py_bases_372;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_373[] = { "__init__", "kill_workers", "terminate_workers", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures.process.ProcessPoolExecutor";
    rt.short_name = "ProcessPoolExecutor";
    rt.method_names = py_methods_373;
    static const char* py_bases_374[] = { "concurrent.futures.process.Executor", NULL };
    rt.embedded_types = py_bases_374;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process.ProcessPoolExecutor.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "concurrent.futures.process.ProcessPoolExecutor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process.ProcessPoolExecutor.kill_workers";
    rf.short_name = "kill_workers";
    rf.receiver_type = "concurrent.futures.process.ProcessPoolExecutor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.process.ProcessPoolExecutor.terminate_workers";
    rf.short_name = "terminate_workers";
    rf.receiver_type = "concurrent.futures.process.ProcessPoolExecutor";
    cbm_registry_add_func(reg, rf);

    /* ===== module: concurrent.futures.thread ===== */
    static const char* py_methods_375[] = { "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures.thread._ResolveTaskFunc";
    rt.short_name = "_ResolveTaskFunc";
    rt.method_names = py_methods_375;
    static const char* py_bases_376[] = { "concurrent.futures.thread.Protocol", NULL };
    rt.embedded_types = py_bases_376;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.thread._ResolveTaskFunc.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "concurrent.futures.thread._ResolveTaskFunc";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_377[] = { "prepare", "__init__", "initialize", "finalize", "run", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures.thread.WorkerContext";
    rt.short_name = "WorkerContext";
    rt.method_names = py_methods_377;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.thread.WorkerContext.prepare";
    rf.short_name = "prepare";
    rf.receiver_type = "concurrent.futures.thread.WorkerContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.thread.WorkerContext.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "concurrent.futures.thread.WorkerContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.thread.WorkerContext.initialize";
    rf.short_name = "initialize";
    rf.receiver_type = "concurrent.futures.thread.WorkerContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.thread.WorkerContext.finalize";
    rf.short_name = "finalize";
    rf.receiver_type = "concurrent.futures.thread.WorkerContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.thread.WorkerContext.run";
    rf.short_name = "run";
    rf.receiver_type = "concurrent.futures.thread.WorkerContext";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_378[] = { "__init__", "run", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures.thread._WorkItem";
    rt.short_name = "_WorkItem";
    rt.method_names = py_methods_378;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.thread._WorkItem.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "concurrent.futures.thread._WorkItem";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.thread._WorkItem.run";
    rf.short_name = "run";
    rf.receiver_type = "concurrent.futures.thread._WorkItem";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_379[] = { "__init__", "run", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures.thread._WorkItem";
    rt.short_name = "_WorkItem";
    rt.method_names = py_methods_379;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.thread._WorkItem.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "concurrent.futures.thread._WorkItem";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.thread._WorkItem.run";
    rf.short_name = "run";
    rf.receiver_type = "concurrent.futures.thread._WorkItem";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures.thread.BrokenThreadPool";
    rt.short_name = "BrokenThreadPool";
    static const char* py_bases_380[] = { "concurrent.futures.thread.BrokenExecutor", NULL };
    rt.embedded_types = py_bases_380;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_381[] = { "prepare_context", "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.futures.thread.ThreadPoolExecutor";
    rt.short_name = "ThreadPoolExecutor";
    rt.method_names = py_methods_381;
    static const char* py_bases_382[] = { "concurrent.futures.thread.Executor", NULL };
    rt.embedded_types = py_bases_382;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.thread.ThreadPoolExecutor.prepare_context";
    rf.short_name = "prepare_context";
    rf.receiver_type = "concurrent.futures.thread.ThreadPoolExecutor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.futures.thread.ThreadPoolExecutor.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "concurrent.futures.thread.ThreadPoolExecutor";
    cbm_registry_add_func(reg, rf);

    /* ===== module: concurrent.interpreters ===== */
    static const char* py_methods_383[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.interpreters.ExecutionFailed";
    rt.short_name = "ExecutionFailed";
    rt.method_names = py_methods_383;
    static const char* py_bases_384[] = { "concurrent.interpreters.InterpreterError", NULL };
    rt.embedded_types = py_bases_384;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters.ExecutionFailed.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "concurrent.interpreters.ExecutionFailed";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_385[] = { "id", "whence", "is_running", "close", "prepare_main", "exec", "call", "call_in_thread", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.interpreters.Interpreter";
    rt.short_name = "Interpreter";
    rt.method_names = py_methods_385;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters.Interpreter.id";
    rf.short_name = "id";
    rf.receiver_type = "concurrent.interpreters.Interpreter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters.Interpreter.whence";
    rf.short_name = "whence";
    rf.receiver_type = "concurrent.interpreters.Interpreter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters.Interpreter.is_running";
    rf.short_name = "is_running";
    rf.receiver_type = "concurrent.interpreters.Interpreter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters.Interpreter.close";
    rf.short_name = "close";
    rf.receiver_type = "concurrent.interpreters.Interpreter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters.Interpreter.prepare_main";
    rf.short_name = "prepare_main";
    rf.receiver_type = "concurrent.interpreters.Interpreter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters.Interpreter.exec";
    rf.short_name = "exec";
    rf.receiver_type = "concurrent.interpreters.Interpreter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters.Interpreter.call";
    rf.short_name = "call";
    rf.receiver_type = "concurrent.interpreters.Interpreter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters.Interpreter.call_in_thread";
    rf.short_name = "call_in_thread";
    rf.receiver_type = "concurrent.interpreters.Interpreter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters.create";
    rf.short_name = "create";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters.list_all";
    rf.short_name = "list_all";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters.get_current";
    rf.short_name = "get_current";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters.get_main";
    rf.short_name = "get_main";
    cbm_registry_add_func(reg, rf);

    /* ===== module: concurrent.interpreters._crossinterp ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.interpreters._crossinterp.ItemInterpreterDestroyed";
    rt.short_name = "ItemInterpreterDestroyed";
    static const char* py_bases_386[] = { "concurrent.interpreters._crossinterp.Exception", NULL };
    rt.embedded_types = py_bases_386;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_387[] = { "singleton", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.interpreters._crossinterp.UnboundItem";
    rt.short_name = "UnboundItem";
    rt.method_names = py_methods_387;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters._crossinterp.UnboundItem.singleton";
    rf.short_name = "singleton";
    rf.receiver_type = "concurrent.interpreters._crossinterp.UnboundItem";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters._crossinterp.serialize_unbound";
    rf.short_name = "serialize_unbound";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters._crossinterp.resolve_unbound";
    rf.short_name = "resolve_unbound";
    cbm_registry_add_func(reg, rf);

    /* ===== module: concurrent.interpreters._queues ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.interpreters._queues.QueueEmpty";
    rt.short_name = "QueueEmpty";
    static const char* py_bases_388[] = { "concurrent.interpreters._queues.QueueError", "queue.Empty", NULL };
    rt.embedded_types = py_bases_388;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.interpreters._queues.QueueFull";
    rt.short_name = "QueueFull";
    static const char* py_bases_389[] = { "concurrent.interpreters._queues.QueueError", "queue.Full", NULL };
    rt.embedded_types = py_bases_389;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.interpreters._queues.ItemInterpreterDestroyed";
    rt.short_name = "ItemInterpreterDestroyed";
    static const char* py_bases_390[] = { "concurrent.interpreters._queues.QueueError", "_crossinterp.ItemInterpreterDestroyed", NULL };
    rt.embedded_types = py_bases_390;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_391[] = { "id", "unbounditems", "maxsize", "empty", "full", "qsize", "put", "put_nowait", "get", "get_nowait", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "concurrent.interpreters._queues.Queue";
    rt.short_name = "Queue";
    rt.method_names = py_methods_391;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters._queues.Queue.id";
    rf.short_name = "id";
    rf.receiver_type = "concurrent.interpreters._queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters._queues.Queue.unbounditems";
    rf.short_name = "unbounditems";
    rf.receiver_type = "concurrent.interpreters._queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters._queues.Queue.maxsize";
    rf.short_name = "maxsize";
    rf.receiver_type = "concurrent.interpreters._queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters._queues.Queue.empty";
    rf.short_name = "empty";
    rf.receiver_type = "concurrent.interpreters._queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters._queues.Queue.full";
    rf.short_name = "full";
    rf.receiver_type = "concurrent.interpreters._queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters._queues.Queue.qsize";
    rf.short_name = "qsize";
    rf.receiver_type = "concurrent.interpreters._queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters._queues.Queue.put";
    rf.short_name = "put";
    rf.receiver_type = "concurrent.interpreters._queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters._queues.Queue.put_nowait";
    rf.short_name = "put_nowait";
    rf.receiver_type = "concurrent.interpreters._queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters._queues.Queue.get";
    rf.short_name = "get";
    rf.receiver_type = "concurrent.interpreters._queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters._queues.Queue.get_nowait";
    rf.short_name = "get_nowait";
    rf.receiver_type = "concurrent.interpreters._queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters._queues.create";
    rf.short_name = "create";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "concurrent.interpreters._queues.list_all";
    rf.short_name = "list_all";
    cbm_registry_add_func(reg, rf);

    /* ===== module: contextlib ===== */
    static const char* py_methods_392[] = { "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib.AbstractContextManager";
    rt.short_name = "AbstractContextManager";
    rt.method_names = py_methods_392;
    static const char* py_bases_393[] = { "contextlib.ABC", NULL };
    rt.embedded_types = py_bases_393;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.AbstractContextManager.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "contextlib.AbstractContextManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.AbstractContextManager.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "contextlib.AbstractContextManager";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib.AbstractAsyncContextManager";
    rt.short_name = "AbstractAsyncContextManager";
    static const char* py_bases_394[] = { "contextlib.ABC", NULL };
    rt.embedded_types = py_bases_394;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_395[] = { "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib.ContextDecorator";
    rt.short_name = "ContextDecorator";
    rt.method_names = py_methods_395;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.ContextDecorator.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "contextlib.ContextDecorator";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_396[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib._GeneratorContextManagerBase";
    rt.short_name = "_GeneratorContextManagerBase";
    rt.method_names = py_methods_396;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib._GeneratorContextManagerBase.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "contextlib._GeneratorContextManagerBase";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_397[] = { "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib._GeneratorContextManager";
    rt.short_name = "_GeneratorContextManager";
    rt.method_names = py_methods_397;
    static const char* py_bases_398[] = { "contextlib.ContextDecorator", NULL };
    rt.embedded_types = py_bases_398;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib._GeneratorContextManager.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "contextlib._GeneratorContextManager";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_399[] = { "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib.AsyncContextDecorator";
    rt.short_name = "AsyncContextDecorator";
    rt.method_names = py_methods_399;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.AsyncContextDecorator.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "contextlib.AsyncContextDecorator";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib._AsyncGeneratorContextManager";
    rt.short_name = "_AsyncGeneratorContextManager";
    static const char* py_bases_400[] = { "contextlib.AsyncContextDecorator", NULL };
    rt.embedded_types = py_bases_400;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_401[] = { "close", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib._SupportsClose";
    rt.short_name = "_SupportsClose";
    rt.method_names = py_methods_401;
    static const char* py_bases_402[] = { "contextlib.Protocol", NULL };
    rt.embedded_types = py_bases_402;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib._SupportsClose.close";
    rf.short_name = "close";
    rf.receiver_type = "contextlib._SupportsClose";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_403[] = { "__init__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib.closing";
    rt.short_name = "closing";
    rt.method_names = py_methods_403;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.closing.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "contextlib.closing";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.closing.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "contextlib.closing";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_404[] = { "aclose", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib._SupportsAclose";
    rt.short_name = "_SupportsAclose";
    rt.method_names = py_methods_404;
    static const char* py_bases_405[] = { "contextlib.Protocol", NULL };
    rt.embedded_types = py_bases_405;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib._SupportsAclose.aclose";
    rf.short_name = "aclose";
    rf.receiver_type = "contextlib._SupportsAclose";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_406[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib.aclosing";
    rt.short_name = "aclosing";
    rt.method_names = py_methods_406;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.aclosing.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "contextlib.aclosing";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_407[] = { "__init__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib.suppress";
    rt.short_name = "suppress";
    rt.method_names = py_methods_407;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.suppress.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "contextlib.suppress";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.suppress.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "contextlib.suppress";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_408[] = { "write", "flush", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib._SupportsRedirect";
    rt.short_name = "_SupportsRedirect";
    rt.method_names = py_methods_408;
    static const char* py_bases_409[] = { "contextlib.Protocol", NULL };
    rt.embedded_types = py_bases_409;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib._SupportsRedirect.write";
    rf.short_name = "write";
    rf.receiver_type = "contextlib._SupportsRedirect";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib._SupportsRedirect.flush";
    rf.short_name = "flush";
    rf.receiver_type = "contextlib._SupportsRedirect";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_410[] = { "__init__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib._RedirectStream";
    rt.short_name = "_RedirectStream";
    rt.method_names = py_methods_410;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib._RedirectStream.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "contextlib._RedirectStream";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib._RedirectStream.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "contextlib._RedirectStream";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib.redirect_stdout";
    rt.short_name = "redirect_stdout";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib.redirect_stderr";
    rt.short_name = "redirect_stderr";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_411[] = { "enter_context", "push", "callback", "pop_all", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib._BaseExitStack";
    rt.short_name = "_BaseExitStack";
    rt.method_names = py_methods_411;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib._BaseExitStack.enter_context";
    rf.short_name = "enter_context";
    rf.receiver_type = "contextlib._BaseExitStack";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib._BaseExitStack.push";
    rf.short_name = "push";
    rf.receiver_type = "contextlib._BaseExitStack";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib._BaseExitStack.callback";
    rf.short_name = "callback";
    rf.receiver_type = "contextlib._BaseExitStack";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib._BaseExitStack.pop_all";
    rf.short_name = "pop_all";
    rf.receiver_type = "contextlib._BaseExitStack";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib._BaseExitStackAbstract";
    rt.short_name = "_BaseExitStackAbstract";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_412[] = { "close", "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib.ExitStack";
    rt.short_name = "ExitStack";
    rt.method_names = py_methods_412;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.ExitStack.close";
    rf.short_name = "close";
    rf.receiver_type = "contextlib.ExitStack";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.ExitStack.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "contextlib.ExitStack";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.ExitStack.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "contextlib.ExitStack";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_413[] = { "enter_async_context", "push_async_exit", "push_async_callback", "aclose", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib.AsyncExitStack";
    rt.short_name = "AsyncExitStack";
    rt.method_names = py_methods_413;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.AsyncExitStack.enter_async_context";
    rf.short_name = "enter_async_context";
    rf.receiver_type = "contextlib.AsyncExitStack";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.AsyncExitStack.push_async_exit";
    rf.short_name = "push_async_exit";
    rf.receiver_type = "contextlib.AsyncExitStack";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.AsyncExitStack.push_async_callback";
    rf.short_name = "push_async_callback";
    rf.receiver_type = "contextlib.AsyncExitStack";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.AsyncExitStack.aclose";
    rf.short_name = "aclose";
    rf.receiver_type = "contextlib.AsyncExitStack";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_414[] = { "__init__", "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib.nullcontext";
    rt.short_name = "nullcontext";
    rt.method_names = py_methods_414;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.nullcontext.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "contextlib.nullcontext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.nullcontext.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "contextlib.nullcontext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.nullcontext.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "contextlib.nullcontext";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_415[] = { "__init__", "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "contextlib.chdir";
    rt.short_name = "chdir";
    rt.method_names = py_methods_415;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.chdir.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "contextlib.chdir";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.chdir.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "contextlib.chdir";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.chdir.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "contextlib.chdir";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.contextmanager";
    rf.short_name = "contextmanager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "contextlib.asynccontextmanager";
    rf.short_name = "asynccontextmanager";
    cbm_registry_add_func(reg, rf);

    /* ===== module: copy ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "copy._SupportsReplace";
    rt.short_name = "_SupportsReplace";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "copy.Error";
    rt.short_name = "Error";
    static const char* py_bases_416[] = { "copy.Exception", NULL };
    rt.embedded_types = py_bases_416;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "copy.deepcopy";
    rf.short_name = "deepcopy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "copy.copy";
    rf.short_name = "copy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "copy.replace";
    rf.short_name = "replace";
    cbm_registry_add_func(reg, rf);

    /* ===== module: dataclasses ===== */
    static const char* py_methods_417[] = { "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "dataclasses._DataclassFactory";
    rt.short_name = "_DataclassFactory";
    rt.method_names = py_methods_417;
    static const char* py_bases_418[] = { "dataclasses.Protocol", NULL };
    rt.embedded_types = py_bases_418;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "dataclasses._DataclassFactory.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "dataclasses._DataclassFactory";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "dataclasses._MISSING_TYPE";
    rt.short_name = "_MISSING_TYPE";
    static const char* py_bases_419[] = { "enum.Enum", NULL };
    rt.embedded_types = py_bases_419;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "dataclasses.KW_ONLY";
    rt.short_name = "KW_ONLY";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_420[] = { "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "dataclasses._DefaultFactory";
    rt.short_name = "_DefaultFactory";
    rt.method_names = py_methods_420;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "dataclasses._DefaultFactory.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "dataclasses._DefaultFactory";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_421[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "dataclasses.Field";
    rt.short_name = "Field";
    rt.method_names = py_methods_421;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "dataclasses.Field.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "dataclasses.Field";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "dataclasses.FrozenInstanceError";
    rt.short_name = "FrozenInstanceError";
    static const char* py_bases_422[] = { "dataclasses.AttributeError", NULL };
    rt.embedded_types = py_bases_422;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_423[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "dataclasses.InitVar";
    rt.short_name = "InitVar";
    rt.method_names = py_methods_423;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "dataclasses.InitVar.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "dataclasses.InitVar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "dataclasses.asdict";
    rf.short_name = "asdict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "dataclasses.astuple";
    rf.short_name = "astuple";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "dataclasses.dataclass";
    rf.short_name = "dataclass";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "dataclasses.field";
    rf.short_name = "field";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "dataclasses.fields";
    rf.short_name = "fields";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "dataclasses.is_dataclass";
    rf.short_name = "is_dataclass";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "dataclasses.make_dataclass";
    rf.short_name = "make_dataclass";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "dataclasses.replace";
    rf.short_name = "replace";
    cbm_registry_add_func(reg, rf);

    /* ===== module: datetime ===== */
    static const char* py_methods_424[] = { "tzname", "utcoffset", "dst", "fromutc", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "datetime.tzinfo";
    rt.short_name = "tzinfo";
    rt.method_names = py_methods_424;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.tzinfo.tzname";
    rf.short_name = "tzname";
    rf.receiver_type = "datetime.tzinfo";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.tzinfo.utcoffset";
    rf.short_name = "utcoffset";
    rf.receiver_type = "datetime.tzinfo";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.tzinfo.dst";
    rf.short_name = "dst";
    rf.receiver_type = "datetime.tzinfo";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.tzinfo.fromutc";
    rf.short_name = "fromutc";
    rf.receiver_type = "datetime.tzinfo";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_425[] = { "tzname", "utcoffset", "dst", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "datetime.timezone";
    rt.short_name = "timezone";
    rt.method_names = py_methods_425;
    static const char* py_bases_426[] = { "datetime.tzinfo", NULL };
    rt.embedded_types = py_bases_426;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.timezone.tzname";
    rf.short_name = "tzname";
    rf.receiver_type = "datetime.timezone";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.timezone.utcoffset";
    rf.short_name = "utcoffset";
    rf.receiver_type = "datetime.timezone";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.timezone.dst";
    rf.short_name = "dst";
    rf.receiver_type = "datetime.timezone";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_427[] = { "year", "week", "weekday", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "datetime._IsoCalendarDate";
    rt.short_name = "_IsoCalendarDate";
    rt.method_names = py_methods_427;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime._IsoCalendarDate.year";
    rf.short_name = "year";
    rf.receiver_type = "datetime._IsoCalendarDate";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime._IsoCalendarDate.week";
    rf.short_name = "week";
    rf.receiver_type = "datetime._IsoCalendarDate";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime._IsoCalendarDate.weekday";
    rf.short_name = "weekday";
    rf.receiver_type = "datetime._IsoCalendarDate";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_428[] = { "fromtimestamp", "today", "fromordinal", "fromisoformat", "fromisocalendar", "year", "month", "day", "ctime", "strptime", "strftime", "isoformat", "timetuple", "toordinal", "__replace__", "replace", "weekday", "isoweekday", "isocalendar", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "datetime.date";
    rt.short_name = "date";
    rt.method_names = py_methods_428;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.date.fromtimestamp";
    rf.short_name = "fromtimestamp";
    rf.receiver_type = "datetime.date";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.date.today";
    rf.short_name = "today";
    rf.receiver_type = "datetime.date";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.date.fromordinal";
    rf.short_name = "fromordinal";
    rf.receiver_type = "datetime.date";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.date.fromisoformat";
    rf.short_name = "fromisoformat";
    rf.receiver_type = "datetime.date";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.date.fromisocalendar";
    rf.short_name = "fromisocalendar";
    rf.receiver_type = "datetime.date";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.date.year";
    rf.short_name = "year";
    rf.receiver_type = "datetime.date";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.date.month";
    rf.short_name = "month";
    rf.receiver_type = "datetime.date";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.date.day";
    rf.short_name = "day";
    rf.receiver_type = "datetime.date";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.date.ctime";
    rf.short_name = "ctime";
    rf.receiver_type = "datetime.date";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.date.strptime";
    rf.short_name = "strptime";
    rf.receiver_type = "datetime.date";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.date.strftime";
    rf.short_name = "strftime";
    rf.receiver_type = "datetime.date";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.date.isoformat";
    rf.short_name = "isoformat";
    rf.receiver_type = "datetime.date";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.date.timetuple";
    rf.short_name = "timetuple";
    rf.receiver_type = "datetime.date";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.date.toordinal";
    rf.short_name = "toordinal";
    rf.receiver_type = "datetime.date";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.date.__replace__";
    rf.short_name = "__replace__";
    rf.receiver_type = "datetime.date";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.date.replace";
    rf.short_name = "replace";
    rf.receiver_type = "datetime.date";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.date.weekday";
    rf.short_name = "weekday";
    rf.receiver_type = "datetime.date";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.date.isoweekday";
    rf.short_name = "isoweekday";
    rf.receiver_type = "datetime.date";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.date.isocalendar";
    rf.short_name = "isocalendar";
    rf.receiver_type = "datetime.date";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_429[] = { "hour", "minute", "second", "microsecond", "tzinfo", "fold", "isoformat", "fromisoformat", "strptime", "strftime", "utcoffset", "tzname", "dst", "__replace__", "replace", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "datetime.time";
    rt.short_name = "time";
    rt.method_names = py_methods_429;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.time.hour";
    rf.short_name = "hour";
    rf.receiver_type = "datetime.time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.time.minute";
    rf.short_name = "minute";
    rf.receiver_type = "datetime.time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.time.second";
    rf.short_name = "second";
    rf.receiver_type = "datetime.time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.time.microsecond";
    rf.short_name = "microsecond";
    rf.receiver_type = "datetime.time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.time.tzinfo";
    rf.short_name = "tzinfo";
    rf.receiver_type = "datetime.time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.time.fold";
    rf.short_name = "fold";
    rf.receiver_type = "datetime.time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.time.isoformat";
    rf.short_name = "isoformat";
    rf.receiver_type = "datetime.time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.time.fromisoformat";
    rf.short_name = "fromisoformat";
    rf.receiver_type = "datetime.time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.time.strptime";
    rf.short_name = "strptime";
    rf.receiver_type = "datetime.time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.time.strftime";
    rf.short_name = "strftime";
    rf.receiver_type = "datetime.time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.time.utcoffset";
    rf.short_name = "utcoffset";
    rf.receiver_type = "datetime.time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.time.tzname";
    rf.short_name = "tzname";
    rf.receiver_type = "datetime.time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.time.dst";
    rf.short_name = "dst";
    rf.receiver_type = "datetime.time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.time.__replace__";
    rf.short_name = "__replace__";
    rf.receiver_type = "datetime.time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.time.replace";
    rf.short_name = "replace";
    rf.receiver_type = "datetime.time";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_430[] = { "days", "seconds", "microseconds", "total_seconds", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "datetime.timedelta";
    rt.short_name = "timedelta";
    rt.method_names = py_methods_430;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.timedelta.days";
    rf.short_name = "days";
    rf.receiver_type = "datetime.timedelta";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.timedelta.seconds";
    rf.short_name = "seconds";
    rf.receiver_type = "datetime.timedelta";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.timedelta.microseconds";
    rf.short_name = "microseconds";
    rf.receiver_type = "datetime.timedelta";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.timedelta.total_seconds";
    rf.short_name = "total_seconds";
    rf.receiver_type = "datetime.timedelta";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_431[] = { "hour", "minute", "second", "microsecond", "tzinfo", "fold", "fromtimestamp", "utcfromtimestamp", "now", "utcnow", "combine", "timestamp", "utctimetuple", "date", "time", "timetz", "__replace__", "replace", "astimezone", "isoformat", "strptime", "utcoffset", "tzname", "dst", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "datetime.datetime";
    rt.short_name = "datetime";
    rt.method_names = py_methods_431;
    static const char* py_bases_432[] = { "datetime.date", NULL };
    rt.embedded_types = py_bases_432;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.hour";
    rf.short_name = "hour";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.minute";
    rf.short_name = "minute";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.second";
    rf.short_name = "second";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.microsecond";
    rf.short_name = "microsecond";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.tzinfo";
    rf.short_name = "tzinfo";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.fold";
    rf.short_name = "fold";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.fromtimestamp";
    rf.short_name = "fromtimestamp";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.utcfromtimestamp";
    rf.short_name = "utcfromtimestamp";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.now";
    rf.short_name = "now";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.utcnow";
    rf.short_name = "utcnow";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.combine";
    rf.short_name = "combine";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.timestamp";
    rf.short_name = "timestamp";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.utctimetuple";
    rf.short_name = "utctimetuple";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.date";
    rf.short_name = "date";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.time";
    rf.short_name = "time";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.timetz";
    rf.short_name = "timetz";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.__replace__";
    rf.short_name = "__replace__";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.replace";
    rf.short_name = "replace";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.astimezone";
    rf.short_name = "astimezone";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.isoformat";
    rf.short_name = "isoformat";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.strptime";
    rf.short_name = "strptime";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.utcoffset";
    rf.short_name = "utcoffset";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.tzname";
    rf.short_name = "tzname";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "datetime.datetime.dst";
    rf.short_name = "dst";
    rf.receiver_type = "datetime.datetime";
    cbm_registry_add_func(reg, rf);

    /* ===== module: enum ===== */
    static const char* py_methods_433[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "enum.nonmember";
    rt.short_name = "nonmember";
    rt.method_names = py_methods_433;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.nonmember.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "enum.nonmember";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_434[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "enum.member";
    rt.short_name = "member";
    rt.method_names = py_methods_434;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.member.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "enum.member";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_435[] = { "__init__", "update", "member_names", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "enum._EnumDict";
    rt.short_name = "_EnumDict";
    rt.method_names = py_methods_435;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum._EnumDict.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "enum._EnumDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum._EnumDict.update";
    rf.short_name = "update";
    rf.receiver_type = "enum._EnumDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum._EnumDict.member_names";
    rf.short_name = "member_names";
    rf.receiver_type = "enum._EnumDict";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_436[] = { "__new__", "__contains__", "__call__", "__signature__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "enum.EnumMeta";
    rt.short_name = "EnumMeta";
    rt.method_names = py_methods_436;
    static const char* py_bases_437[] = { "enum.type", NULL };
    rt.embedded_types = py_bases_437;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.EnumMeta.__new__";
    rf.short_name = "__new__";
    rf.receiver_type = "enum.EnumMeta";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.EnumMeta.__contains__";
    rf.short_name = "__contains__";
    rf.receiver_type = "enum.EnumMeta";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.EnumMeta.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "enum.EnumMeta";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.EnumMeta.__signature__";
    rf.short_name = "__signature__";
    rf.receiver_type = "enum.EnumMeta";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "enum.property";
    rt.short_name = "property";
    static const char* py_bases_438[] = { "types.DynamicClassAttribute", NULL };
    rt.embedded_types = py_bases_438;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_439[] = { "name", "value", "__copy__", "__deepcopy__", "__signature__", "_add_value_alias_", "_add_alias_", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "enum.Enum";
    rt.short_name = "Enum";
    rt.method_names = py_methods_439;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.Enum.name";
    rf.short_name = "name";
    rf.receiver_type = "enum.Enum";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.Enum.value";
    rf.short_name = "value";
    rf.receiver_type = "enum.Enum";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.Enum.__copy__";
    rf.short_name = "__copy__";
    rf.receiver_type = "enum.Enum";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.Enum.__deepcopy__";
    rf.short_name = "__deepcopy__";
    rf.receiver_type = "enum.Enum";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.Enum.__signature__";
    rf.short_name = "__signature__";
    rf.receiver_type = "enum.Enum";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.Enum._add_value_alias_";
    rf.short_name = "_add_value_alias_";
    rf.receiver_type = "enum.Enum";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.Enum._add_alias_";
    rf.short_name = "_add_alias_";
    rf.receiver_type = "enum.Enum";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "enum.ReprEnum";
    rt.short_name = "ReprEnum";
    static const char* py_bases_440[] = { "enum.Enum", NULL };
    rt.embedded_types = py_bases_440;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_441[] = { "value", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "enum.IntEnum";
    rt.short_name = "IntEnum";
    rt.method_names = py_methods_441;
    static const char* py_bases_442[] = { "enum.int", "enum.ReprEnum", NULL };
    rt.embedded_types = py_bases_442;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.IntEnum.value";
    rf.short_name = "value";
    rf.receiver_type = "enum.IntEnum";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_443[] = { "value", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "enum.IntEnum";
    rt.short_name = "IntEnum";
    rt.method_names = py_methods_443;
    static const char* py_bases_444[] = { "enum.int", "enum._IntEnumBase", NULL };
    rt.embedded_types = py_bases_444;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.IntEnum.value";
    rf.short_name = "value";
    rf.receiver_type = "enum.IntEnum";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_445[] = { "name", "value", "__iter__", "__len__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "enum.Flag";
    rt.short_name = "Flag";
    rt.method_names = py_methods_445;
    static const char* py_bases_446[] = { "enum.Enum", NULL };
    rt.embedded_types = py_bases_446;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.Flag.name";
    rf.short_name = "name";
    rf.receiver_type = "enum.Flag";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.Flag.value";
    rf.short_name = "value";
    rf.receiver_type = "enum.Flag";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.Flag.__iter__";
    rf.short_name = "__iter__";
    rf.receiver_type = "enum.Flag";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.Flag.__len__";
    rf.short_name = "__len__";
    rf.receiver_type = "enum.Flag";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_447[] = { "value", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "enum.StrEnum";
    rt.short_name = "StrEnum";
    rt.method_names = py_methods_447;
    static const char* py_bases_448[] = { "enum.str", "enum.ReprEnum", NULL };
    rt.embedded_types = py_bases_448;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.StrEnum.value";
    rf.short_name = "value";
    rf.receiver_type = "enum.StrEnum";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "enum.EnumCheck";
    rt.short_name = "EnumCheck";
    static const char* py_bases_449[] = { "enum.StrEnum", NULL };
    rt.embedded_types = py_bases_449;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_450[] = { "__init__", "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "enum.verify";
    rt.short_name = "verify";
    rt.method_names = py_methods_450;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.verify.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "enum.verify";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.verify.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "enum.verify";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "enum.FlagBoundary";
    rt.short_name = "FlagBoundary";
    static const char* py_bases_451[] = { "enum.StrEnum", NULL };
    rt.embedded_types = py_bases_451;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "enum.IntFlag";
    rt.short_name = "IntFlag";
    static const char* py_bases_452[] = { "enum.int", "enum.ReprEnum", "enum.Flag", NULL };
    rt.embedded_types = py_bases_452;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "enum.IntFlag";
    rt.short_name = "IntFlag";
    static const char* py_bases_453[] = { "enum.int", "enum.ReprEnum", "enum.Flag", NULL };
    rt.embedded_types = py_bases_453;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "enum.IntFlag";
    rt.short_name = "IntFlag";
    static const char* py_bases_454[] = { "enum.int", "enum.Flag", NULL };
    rt.embedded_types = py_bases_454;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_455[] = { "value", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "enum.auto";
    rt.short_name = "auto";
    rt.method_names = py_methods_455;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.auto.value";
    rf.short_name = "value";
    rf.receiver_type = "enum.auto";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.unique";
    rf.short_name = "unique";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.global_str";
    rf.short_name = "global_str";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.global_enum";
    rf.short_name = "global_enum";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.global_enum_repr";
    rf.short_name = "global_enum_repr";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.global_flag_repr";
    rf.short_name = "global_flag_repr";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.show_flag_values";
    rf.short_name = "show_flag_values";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.bin";
    rf.short_name = "bin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.pickle_by_global_name";
    rf.short_name = "pickle_by_global_name";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "enum.pickle_by_enum_name";
    rf.short_name = "pickle_by_enum_name";
    cbm_registry_add_func(reg, rf);

    /* ===== module: functools ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "functools._CacheInfo";
    rt.short_name = "_CacheInfo";
    static const char* py_bases_456[] = { "functools.NamedTuple", NULL };
    rt.embedded_types = py_bases_456;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "functools._CacheParameters";
    rt.short_name = "_CacheParameters";
    static const char* py_bases_457[] = { "functools.TypedDict", NULL };
    rt.embedded_types = py_bases_457;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_458[] = { "__call__", "cache_info", "cache_clear", "cache_parameters", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "functools._lru_cache_wrapper";
    rt.short_name = "_lru_cache_wrapper";
    rt.method_names = py_methods_458;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools._lru_cache_wrapper.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "functools._lru_cache_wrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools._lru_cache_wrapper.cache_info";
    rf.short_name = "cache_info";
    rf.receiver_type = "functools._lru_cache_wrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools._lru_cache_wrapper.cache_clear";
    rf.short_name = "cache_clear";
    rf.receiver_type = "functools._lru_cache_wrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools._lru_cache_wrapper.cache_parameters";
    rf.short_name = "cache_parameters";
    rf.receiver_type = "functools._lru_cache_wrapper";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_459[] = { "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "functools._Wrapped";
    rt.short_name = "_Wrapped";
    rt.method_names = py_methods_459;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools._Wrapped.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "functools._Wrapped";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_460[] = { "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "functools._Wrapper";
    rt.short_name = "_Wrapper";
    rt.method_names = py_methods_460;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools._Wrapper.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "functools._Wrapper";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_461[] = { "func", "args", "keywords", "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "functools.partial";
    rt.short_name = "partial";
    rt.method_names = py_methods_461;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools.partial.func";
    rf.short_name = "func";
    rf.receiver_type = "functools.partial";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools.partial.args";
    rf.short_name = "args";
    rf.receiver_type = "functools.partial";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools.partial.keywords";
    rf.short_name = "keywords";
    rf.receiver_type = "functools.partial";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools.partial.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "functools.partial";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_462[] = { "__new__", "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "functools.partialmethod";
    rt.short_name = "partialmethod";
    rt.method_names = py_methods_462;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools.partialmethod.__new__";
    rf.short_name = "__new__";
    rf.receiver_type = "functools.partialmethod";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools.partialmethod.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "functools.partialmethod";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_463[] = { "dispatch", "register", "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "functools._SingleDispatchCallable";
    rt.short_name = "_SingleDispatchCallable";
    rt.method_names = py_methods_463;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools._SingleDispatchCallable.dispatch";
    rf.short_name = "dispatch";
    rf.receiver_type = "functools._SingleDispatchCallable";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools._SingleDispatchCallable.register";
    rf.short_name = "register";
    rf.receiver_type = "functools._SingleDispatchCallable";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools._SingleDispatchCallable.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "functools._SingleDispatchCallable";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_464[] = { "__init__", "register", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "functools.singledispatchmethod";
    rt.short_name = "singledispatchmethod";
    rt.method_names = py_methods_464;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools.singledispatchmethod.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "functools.singledispatchmethod";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools.singledispatchmethod.register";
    rf.short_name = "register";
    rf.receiver_type = "functools.singledispatchmethod";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_465[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "functools.cached_property";
    rt.short_name = "cached_property";
    rt.method_names = py_methods_465;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools.cached_property.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "functools.cached_property";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "functools._PlaceholderType";
    rt.short_name = "_PlaceholderType";
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools.reduce";
    rf.short_name = "reduce";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools.lru_cache";
    rf.short_name = "lru_cache";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools.update_wrapper";
    rf.short_name = "update_wrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools.wraps";
    rf.short_name = "wraps";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools.total_ordering";
    rf.short_name = "total_ordering";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools.cmp_to_key";
    rf.short_name = "cmp_to_key";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools.singledispatch";
    rf.short_name = "singledispatch";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "functools.cache";
    rf.short_name = "cache";
    cbm_registry_add_func(reg, rf);

    /* ===== module: http ===== */
    static const char* py_methods_466[] = { "phrase", "description", "is_informational", "is_success", "is_redirection", "is_client_error", "is_server_error", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.HTTPStatus";
    rt.short_name = "HTTPStatus";
    rt.method_names = py_methods_466;
    static const char* py_bases_467[] = { "http.IntEnum", NULL };
    rt.embedded_types = py_bases_467;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.HTTPStatus.phrase";
    rf.short_name = "phrase";
    rf.receiver_type = "http.HTTPStatus";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.HTTPStatus.description";
    rf.short_name = "description";
    rf.receiver_type = "http.HTTPStatus";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.HTTPStatus.is_informational";
    rf.short_name = "is_informational";
    rf.receiver_type = "http.HTTPStatus";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.HTTPStatus.is_success";
    rf.short_name = "is_success";
    rf.receiver_type = "http.HTTPStatus";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.HTTPStatus.is_redirection";
    rf.short_name = "is_redirection";
    rf.receiver_type = "http.HTTPStatus";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.HTTPStatus.is_client_error";
    rf.short_name = "is_client_error";
    rf.receiver_type = "http.HTTPStatus";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.HTTPStatus.is_server_error";
    rf.short_name = "is_server_error";
    rf.receiver_type = "http.HTTPStatus";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_468[] = { "description", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.HTTPMethod";
    rt.short_name = "HTTPMethod";
    rt.method_names = py_methods_468;
    static const char* py_bases_469[] = { "http.StrEnum", NULL };
    rt.embedded_types = py_bases_469;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.HTTPMethod.description";
    rf.short_name = "description";
    rf.receiver_type = "http.HTTPMethod";
    cbm_registry_add_func(reg, rf);

    /* ===== module: http.client ===== */
    static const char* py_methods_470[] = { "getallmatchingheaders", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.client.HTTPMessage";
    rt.short_name = "HTTPMessage";
    rt.method_names = py_methods_470;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPMessage.getallmatchingheaders";
    rf.short_name = "getallmatchingheaders";
    rf.receiver_type = "http.client.HTTPMessage";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_471[] = { "__init__", "peek", "read", "read1", "readinto", "readline", "getheader", "getheaders", "isclosed", "__enter__", "__exit__", "info", "geturl", "getcode", "begin", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.client.HTTPResponse";
    rt.short_name = "HTTPResponse";
    rt.method_names = py_methods_471;
    static const char* py_bases_472[] = { "io.BufferedIOBase", "http.client.BinaryIO", NULL };
    rt.embedded_types = py_bases_472;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPResponse.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "http.client.HTTPResponse";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPResponse.peek";
    rf.short_name = "peek";
    rf.receiver_type = "http.client.HTTPResponse";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPResponse.read";
    rf.short_name = "read";
    rf.receiver_type = "http.client.HTTPResponse";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPResponse.read1";
    rf.short_name = "read1";
    rf.receiver_type = "http.client.HTTPResponse";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPResponse.readinto";
    rf.short_name = "readinto";
    rf.receiver_type = "http.client.HTTPResponse";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPResponse.readline";
    rf.short_name = "readline";
    rf.receiver_type = "http.client.HTTPResponse";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPResponse.getheader";
    rf.short_name = "getheader";
    rf.receiver_type = "http.client.HTTPResponse";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPResponse.getheaders";
    rf.short_name = "getheaders";
    rf.receiver_type = "http.client.HTTPResponse";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPResponse.isclosed";
    rf.short_name = "isclosed";
    rf.receiver_type = "http.client.HTTPResponse";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPResponse.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "http.client.HTTPResponse";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPResponse.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "http.client.HTTPResponse";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPResponse.info";
    rf.short_name = "info";
    rf.receiver_type = "http.client.HTTPResponse";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPResponse.geturl";
    rf.short_name = "geturl";
    rf.receiver_type = "http.client.HTTPResponse";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPResponse.getcode";
    rf.short_name = "getcode";
    rf.receiver_type = "http.client.HTTPResponse";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPResponse.begin";
    rf.short_name = "begin";
    rf.receiver_type = "http.client.HTTPResponse";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_473[] = { "__init__", "request", "getresponse", "set_debuglevel", "get_proxy_response_headers", "set_tunnel", "connect", "close", "putrequest", "putheader", "endheaders", "send", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.client.HTTPConnection";
    rt.short_name = "HTTPConnection";
    rt.method_names = py_methods_473;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPConnection.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "http.client.HTTPConnection";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPConnection.request";
    rf.short_name = "request";
    rf.receiver_type = "http.client.HTTPConnection";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPConnection.getresponse";
    rf.short_name = "getresponse";
    rf.receiver_type = "http.client.HTTPConnection";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPConnection.set_debuglevel";
    rf.short_name = "set_debuglevel";
    rf.receiver_type = "http.client.HTTPConnection";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPConnection.get_proxy_response_headers";
    rf.short_name = "get_proxy_response_headers";
    rf.receiver_type = "http.client.HTTPConnection";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPConnection.set_tunnel";
    rf.short_name = "set_tunnel";
    rf.receiver_type = "http.client.HTTPConnection";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPConnection.connect";
    rf.short_name = "connect";
    rf.receiver_type = "http.client.HTTPConnection";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPConnection.close";
    rf.short_name = "close";
    rf.receiver_type = "http.client.HTTPConnection";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPConnection.putrequest";
    rf.short_name = "putrequest";
    rf.receiver_type = "http.client.HTTPConnection";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPConnection.putheader";
    rf.short_name = "putheader";
    rf.receiver_type = "http.client.HTTPConnection";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPConnection.endheaders";
    rf.short_name = "endheaders";
    rf.receiver_type = "http.client.HTTPConnection";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPConnection.send";
    rf.short_name = "send";
    rf.receiver_type = "http.client.HTTPConnection";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_474[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.client.HTTPSConnection";
    rt.short_name = "HTTPSConnection";
    rt.method_names = py_methods_474;
    static const char* py_bases_475[] = { "http.client.HTTPConnection", NULL };
    rt.embedded_types = py_bases_475;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.HTTPSConnection.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "http.client.HTTPSConnection";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.client.HTTPException";
    rt.short_name = "HTTPException";
    static const char* py_bases_476[] = { "http.client.Exception", NULL };
    rt.embedded_types = py_bases_476;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.client.NotConnected";
    rt.short_name = "NotConnected";
    static const char* py_bases_477[] = { "http.client.HTTPException", NULL };
    rt.embedded_types = py_bases_477;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.client.InvalidURL";
    rt.short_name = "InvalidURL";
    static const char* py_bases_478[] = { "http.client.HTTPException", NULL };
    rt.embedded_types = py_bases_478;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_479[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.client.UnknownProtocol";
    rt.short_name = "UnknownProtocol";
    rt.method_names = py_methods_479;
    static const char* py_bases_480[] = { "http.client.HTTPException", NULL };
    rt.embedded_types = py_bases_480;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.UnknownProtocol.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "http.client.UnknownProtocol";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.client.UnknownTransferEncoding";
    rt.short_name = "UnknownTransferEncoding";
    static const char* py_bases_481[] = { "http.client.HTTPException", NULL };
    rt.embedded_types = py_bases_481;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.client.UnimplementedFileMode";
    rt.short_name = "UnimplementedFileMode";
    static const char* py_bases_482[] = { "http.client.HTTPException", NULL };
    rt.embedded_types = py_bases_482;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_483[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.client.IncompleteRead";
    rt.short_name = "IncompleteRead";
    rt.method_names = py_methods_483;
    static const char* py_bases_484[] = { "http.client.HTTPException", NULL };
    rt.embedded_types = py_bases_484;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.IncompleteRead.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "http.client.IncompleteRead";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.client.ImproperConnectionState";
    rt.short_name = "ImproperConnectionState";
    static const char* py_bases_485[] = { "http.client.HTTPException", NULL };
    rt.embedded_types = py_bases_485;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.client.CannotSendRequest";
    rt.short_name = "CannotSendRequest";
    static const char* py_bases_486[] = { "http.client.ImproperConnectionState", NULL };
    rt.embedded_types = py_bases_486;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.client.CannotSendHeader";
    rt.short_name = "CannotSendHeader";
    static const char* py_bases_487[] = { "http.client.ImproperConnectionState", NULL };
    rt.embedded_types = py_bases_487;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.client.ResponseNotReady";
    rt.short_name = "ResponseNotReady";
    static const char* py_bases_488[] = { "http.client.ImproperConnectionState", NULL };
    rt.embedded_types = py_bases_488;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_489[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.client.BadStatusLine";
    rt.short_name = "BadStatusLine";
    rt.method_names = py_methods_489;
    static const char* py_bases_490[] = { "http.client.HTTPException", NULL };
    rt.embedded_types = py_bases_490;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.BadStatusLine.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "http.client.BadStatusLine";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_491[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.client.LineTooLong";
    rt.short_name = "LineTooLong";
    rt.method_names = py_methods_491;
    static const char* py_bases_492[] = { "http.client.HTTPException", NULL };
    rt.embedded_types = py_bases_492;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.LineTooLong.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "http.client.LineTooLong";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.client.RemoteDisconnected";
    rt.short_name = "RemoteDisconnected";
    static const char* py_bases_493[] = { "http.client.ConnectionResetError", "http.client.BadStatusLine", NULL };
    rt.embedded_types = py_bases_493;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.client.parse_headers";
    rf.short_name = "parse_headers";
    cbm_registry_add_func(reg, rf);

    /* ===== module: http.cookiejar ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.cookiejar.LoadError";
    rt.short_name = "LoadError";
    static const char* py_bases_494[] = { "http.cookiejar.OSError", NULL };
    rt.embedded_types = py_bases_494;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_495[] = { "__init__", "add_cookie_header", "extract_cookies", "set_policy", "make_cookies", "set_cookie", "set_cookie_if_ok", "clear", "clear_session_cookies", "clear_expired_cookies", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.cookiejar.CookieJar";
    rt.short_name = "CookieJar";
    rt.method_names = py_methods_495;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.CookieJar.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "http.cookiejar.CookieJar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.CookieJar.add_cookie_header";
    rf.short_name = "add_cookie_header";
    rf.receiver_type = "http.cookiejar.CookieJar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.CookieJar.extract_cookies";
    rf.short_name = "extract_cookies";
    rf.receiver_type = "http.cookiejar.CookieJar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.CookieJar.set_policy";
    rf.short_name = "set_policy";
    rf.receiver_type = "http.cookiejar.CookieJar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.CookieJar.make_cookies";
    rf.short_name = "make_cookies";
    rf.receiver_type = "http.cookiejar.CookieJar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.CookieJar.set_cookie";
    rf.short_name = "set_cookie";
    rf.receiver_type = "http.cookiejar.CookieJar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.CookieJar.set_cookie_if_ok";
    rf.short_name = "set_cookie_if_ok";
    rf.receiver_type = "http.cookiejar.CookieJar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.CookieJar.clear";
    rf.short_name = "clear";
    rf.receiver_type = "http.cookiejar.CookieJar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.CookieJar.clear_session_cookies";
    rf.short_name = "clear_session_cookies";
    rf.receiver_type = "http.cookiejar.CookieJar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.CookieJar.clear_expired_cookies";
    rf.short_name = "clear_expired_cookies";
    rf.receiver_type = "http.cookiejar.CookieJar";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_496[] = { "__init__", "save", "load", "revert", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.cookiejar.FileCookieJar";
    rt.short_name = "FileCookieJar";
    rt.method_names = py_methods_496;
    static const char* py_bases_497[] = { "http.cookiejar.CookieJar", NULL };
    rt.embedded_types = py_bases_497;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.FileCookieJar.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "http.cookiejar.FileCookieJar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.FileCookieJar.save";
    rf.short_name = "save";
    rf.receiver_type = "http.cookiejar.FileCookieJar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.FileCookieJar.load";
    rf.short_name = "load";
    rf.receiver_type = "http.cookiejar.FileCookieJar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.FileCookieJar.revert";
    rf.short_name = "revert";
    rf.receiver_type = "http.cookiejar.FileCookieJar";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.cookiejar.MozillaCookieJar";
    rt.short_name = "MozillaCookieJar";
    static const char* py_bases_498[] = { "http.cookiejar.FileCookieJar", NULL };
    rt.embedded_types = py_bases_498;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_499[] = { "as_lwp_str", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.cookiejar.LWPCookieJar";
    rt.short_name = "LWPCookieJar";
    rt.method_names = py_methods_499;
    static const char* py_bases_500[] = { "http.cookiejar.FileCookieJar", NULL };
    rt.embedded_types = py_bases_500;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.LWPCookieJar.as_lwp_str";
    rf.short_name = "as_lwp_str";
    rf.receiver_type = "http.cookiejar.LWPCookieJar";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_501[] = { "set_ok", "return_ok", "domain_return_ok", "path_return_ok", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.cookiejar.CookiePolicy";
    rt.short_name = "CookiePolicy";
    rt.method_names = py_methods_501;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.CookiePolicy.set_ok";
    rf.short_name = "set_ok";
    rf.receiver_type = "http.cookiejar.CookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.CookiePolicy.return_ok";
    rf.short_name = "return_ok";
    rf.receiver_type = "http.cookiejar.CookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.CookiePolicy.domain_return_ok";
    rf.short_name = "domain_return_ok";
    rf.receiver_type = "http.cookiejar.CookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.CookiePolicy.path_return_ok";
    rf.short_name = "path_return_ok";
    rf.receiver_type = "http.cookiejar.CookiePolicy";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_502[] = { "__init__", "blocked_domains", "set_blocked_domains", "is_blocked", "allowed_domains", "set_allowed_domains", "is_not_allowed", "set_ok_version", "set_ok_verifiability", "set_ok_name", "set_ok_path", "set_ok_domain", "set_ok_port", "return_ok_version", "return_ok_verifiability", "return_ok_secure", "return_ok_expires", "return_ok_port", "return_ok_domain", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.cookiejar.DefaultCookiePolicy";
    rt.short_name = "DefaultCookiePolicy";
    rt.method_names = py_methods_502;
    static const char* py_bases_503[] = { "http.cookiejar.CookiePolicy", NULL };
    rt.embedded_types = py_bases_503;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "http.cookiejar.DefaultCookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.blocked_domains";
    rf.short_name = "blocked_domains";
    rf.receiver_type = "http.cookiejar.DefaultCookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.set_blocked_domains";
    rf.short_name = "set_blocked_domains";
    rf.receiver_type = "http.cookiejar.DefaultCookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.is_blocked";
    rf.short_name = "is_blocked";
    rf.receiver_type = "http.cookiejar.DefaultCookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.allowed_domains";
    rf.short_name = "allowed_domains";
    rf.receiver_type = "http.cookiejar.DefaultCookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.set_allowed_domains";
    rf.short_name = "set_allowed_domains";
    rf.receiver_type = "http.cookiejar.DefaultCookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.is_not_allowed";
    rf.short_name = "is_not_allowed";
    rf.receiver_type = "http.cookiejar.DefaultCookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.set_ok_version";
    rf.short_name = "set_ok_version";
    rf.receiver_type = "http.cookiejar.DefaultCookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.set_ok_verifiability";
    rf.short_name = "set_ok_verifiability";
    rf.receiver_type = "http.cookiejar.DefaultCookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.set_ok_name";
    rf.short_name = "set_ok_name";
    rf.receiver_type = "http.cookiejar.DefaultCookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.set_ok_path";
    rf.short_name = "set_ok_path";
    rf.receiver_type = "http.cookiejar.DefaultCookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.set_ok_domain";
    rf.short_name = "set_ok_domain";
    rf.receiver_type = "http.cookiejar.DefaultCookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.set_ok_port";
    rf.short_name = "set_ok_port";
    rf.receiver_type = "http.cookiejar.DefaultCookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.return_ok_version";
    rf.short_name = "return_ok_version";
    rf.receiver_type = "http.cookiejar.DefaultCookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.return_ok_verifiability";
    rf.short_name = "return_ok_verifiability";
    rf.receiver_type = "http.cookiejar.DefaultCookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.return_ok_secure";
    rf.short_name = "return_ok_secure";
    rf.receiver_type = "http.cookiejar.DefaultCookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.return_ok_expires";
    rf.short_name = "return_ok_expires";
    rf.receiver_type = "http.cookiejar.DefaultCookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.return_ok_port";
    rf.short_name = "return_ok_port";
    rf.receiver_type = "http.cookiejar.DefaultCookiePolicy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.DefaultCookiePolicy.return_ok_domain";
    rf.short_name = "return_ok_domain";
    rf.receiver_type = "http.cookiejar.DefaultCookiePolicy";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_504[] = { "__init__", "has_nonstandard_attr", "get_nonstandard_attr", "set_nonstandard_attr", "is_expired", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.cookiejar.Cookie";
    rt.short_name = "Cookie";
    rt.method_names = py_methods_504;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.Cookie.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "http.cookiejar.Cookie";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.Cookie.has_nonstandard_attr";
    rf.short_name = "has_nonstandard_attr";
    rf.receiver_type = "http.cookiejar.Cookie";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.Cookie.get_nonstandard_attr";
    rf.short_name = "get_nonstandard_attr";
    rf.receiver_type = "http.cookiejar.Cookie";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.Cookie.set_nonstandard_attr";
    rf.short_name = "set_nonstandard_attr";
    rf.receiver_type = "http.cookiejar.Cookie";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookiejar.Cookie.is_expired";
    rf.short_name = "is_expired";
    rf.receiver_type = "http.cookiejar.Cookie";
    cbm_registry_add_func(reg, rf);

    /* ===== module: http.cookies ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.cookies.CookieError";
    rt.short_name = "CookieError";
    static const char* py_bases_505[] = { "http.cookies.Exception", NULL };
    rt.embedded_types = py_bases_505;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_506[] = { "value", "coded_value", "key", "__init__", "set", "setdefault", "update", "isReservedKey", "output", "js_output", "OutputString", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.cookies.Morsel";
    rt.short_name = "Morsel";
    rt.method_names = py_methods_506;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookies.Morsel.value";
    rf.short_name = "value";
    rf.receiver_type = "http.cookies.Morsel";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookies.Morsel.coded_value";
    rf.short_name = "coded_value";
    rf.receiver_type = "http.cookies.Morsel";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookies.Morsel.key";
    rf.short_name = "key";
    rf.receiver_type = "http.cookies.Morsel";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookies.Morsel.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "http.cookies.Morsel";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookies.Morsel.set";
    rf.short_name = "set";
    rf.receiver_type = "http.cookies.Morsel";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookies.Morsel.setdefault";
    rf.short_name = "setdefault";
    rf.receiver_type = "http.cookies.Morsel";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookies.Morsel.update";
    rf.short_name = "update";
    rf.receiver_type = "http.cookies.Morsel";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookies.Morsel.isReservedKey";
    rf.short_name = "isReservedKey";
    rf.receiver_type = "http.cookies.Morsel";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookies.Morsel.output";
    rf.short_name = "output";
    rf.receiver_type = "http.cookies.Morsel";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookies.Morsel.js_output";
    rf.short_name = "js_output";
    rf.receiver_type = "http.cookies.Morsel";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookies.Morsel.OutputString";
    rf.short_name = "OutputString";
    rf.receiver_type = "http.cookies.Morsel";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_507[] = { "__init__", "value_decode", "value_encode", "output", "js_output", "load", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.cookies.BaseCookie";
    rt.short_name = "BaseCookie";
    rt.method_names = py_methods_507;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookies.BaseCookie.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "http.cookies.BaseCookie";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookies.BaseCookie.value_decode";
    rf.short_name = "value_decode";
    rf.receiver_type = "http.cookies.BaseCookie";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookies.BaseCookie.value_encode";
    rf.short_name = "value_encode";
    rf.receiver_type = "http.cookies.BaseCookie";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookies.BaseCookie.output";
    rf.short_name = "output";
    rf.receiver_type = "http.cookies.BaseCookie";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookies.BaseCookie.js_output";
    rf.short_name = "js_output";
    rf.receiver_type = "http.cookies.BaseCookie";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.cookies.BaseCookie.load";
    rf.short_name = "load";
    rf.receiver_type = "http.cookies.BaseCookie";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.cookies.SimpleCookie";
    rt.short_name = "SimpleCookie";
    cbm_registry_add_type(reg, rt);

    /* ===== module: http.server ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.server.HTTPServer";
    rt.short_name = "HTTPServer";
    static const char* py_bases_508[] = { "socketserver.TCPServer", NULL };
    rt.embedded_types = py_bases_508;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.server.ThreadingHTTPServer";
    rt.short_name = "ThreadingHTTPServer";
    static const char* py_bases_509[] = { "socketserver.ThreadingMixIn", "http.server.HTTPServer", NULL };
    rt.embedded_types = py_bases_509;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_510[] = { "create_default_context", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.server._SSLModule";
    rt.short_name = "_SSLModule";
    rt.method_names = py_methods_510;
    static const char* py_bases_511[] = { "http.server.Protocol", NULL };
    rt.embedded_types = py_bases_511;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server._SSLModule.create_default_context";
    rf.short_name = "create_default_context";
    rf.receiver_type = "http.server._SSLModule";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_512[] = { "__init__", "server_activate", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.server.HTTPSServer";
    rt.short_name = "HTTPSServer";
    rt.method_names = py_methods_512;
    static const char* py_bases_513[] = { "http.server.HTTPServer", NULL };
    rt.embedded_types = py_bases_513;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.HTTPSServer.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "http.server.HTTPSServer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.HTTPSServer.server_activate";
    rf.short_name = "server_activate";
    rf.receiver_type = "http.server.HTTPSServer";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.server.ThreadingHTTPSServer";
    rt.short_name = "ThreadingHTTPSServer";
    static const char* py_bases_514[] = { "socketserver.ThreadingMixIn", "http.server.HTTPSServer", NULL };
    rt.embedded_types = py_bases_514;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_515[] = { "handle_one_request", "handle_expect_100", "send_error", "send_response", "send_header", "send_response_only", "end_headers", "flush_headers", "log_request", "log_error", "log_message", "version_string", "date_time_string", "log_date_time_string", "address_string", "parse_request", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.server.BaseHTTPRequestHandler";
    rt.short_name = "BaseHTTPRequestHandler";
    rt.method_names = py_methods_515;
    static const char* py_bases_516[] = { "socketserver.StreamRequestHandler", NULL };
    rt.embedded_types = py_bases_516;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.BaseHTTPRequestHandler.handle_one_request";
    rf.short_name = "handle_one_request";
    rf.receiver_type = "http.server.BaseHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.BaseHTTPRequestHandler.handle_expect_100";
    rf.short_name = "handle_expect_100";
    rf.receiver_type = "http.server.BaseHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.BaseHTTPRequestHandler.send_error";
    rf.short_name = "send_error";
    rf.receiver_type = "http.server.BaseHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.BaseHTTPRequestHandler.send_response";
    rf.short_name = "send_response";
    rf.receiver_type = "http.server.BaseHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.BaseHTTPRequestHandler.send_header";
    rf.short_name = "send_header";
    rf.receiver_type = "http.server.BaseHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.BaseHTTPRequestHandler.send_response_only";
    rf.short_name = "send_response_only";
    rf.receiver_type = "http.server.BaseHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.BaseHTTPRequestHandler.end_headers";
    rf.short_name = "end_headers";
    rf.receiver_type = "http.server.BaseHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.BaseHTTPRequestHandler.flush_headers";
    rf.short_name = "flush_headers";
    rf.receiver_type = "http.server.BaseHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.BaseHTTPRequestHandler.log_request";
    rf.short_name = "log_request";
    rf.receiver_type = "http.server.BaseHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.BaseHTTPRequestHandler.log_error";
    rf.short_name = "log_error";
    rf.receiver_type = "http.server.BaseHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.BaseHTTPRequestHandler.log_message";
    rf.short_name = "log_message";
    rf.receiver_type = "http.server.BaseHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.BaseHTTPRequestHandler.version_string";
    rf.short_name = "version_string";
    rf.receiver_type = "http.server.BaseHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.BaseHTTPRequestHandler.date_time_string";
    rf.short_name = "date_time_string";
    rf.receiver_type = "http.server.BaseHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.BaseHTTPRequestHandler.log_date_time_string";
    rf.short_name = "log_date_time_string";
    rf.receiver_type = "http.server.BaseHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.BaseHTTPRequestHandler.address_string";
    rf.short_name = "address_string";
    rf.receiver_type = "http.server.BaseHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.BaseHTTPRequestHandler.parse_request";
    rf.short_name = "parse_request";
    rf.receiver_type = "http.server.BaseHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_517[] = { "__init__", "do_GET", "do_HEAD", "send_head", "list_directory", "translate_path", "copyfile", "guess_type", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.server.SimpleHTTPRequestHandler";
    rt.short_name = "SimpleHTTPRequestHandler";
    rt.method_names = py_methods_517;
    static const char* py_bases_518[] = { "http.server.BaseHTTPRequestHandler", NULL };
    rt.embedded_types = py_bases_518;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.SimpleHTTPRequestHandler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "http.server.SimpleHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.SimpleHTTPRequestHandler.do_GET";
    rf.short_name = "do_GET";
    rf.receiver_type = "http.server.SimpleHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.SimpleHTTPRequestHandler.do_HEAD";
    rf.short_name = "do_HEAD";
    rf.receiver_type = "http.server.SimpleHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.SimpleHTTPRequestHandler.send_head";
    rf.short_name = "send_head";
    rf.receiver_type = "http.server.SimpleHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.SimpleHTTPRequestHandler.list_directory";
    rf.short_name = "list_directory";
    rf.receiver_type = "http.server.SimpleHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.SimpleHTTPRequestHandler.translate_path";
    rf.short_name = "translate_path";
    rf.receiver_type = "http.server.SimpleHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.SimpleHTTPRequestHandler.copyfile";
    rf.short_name = "copyfile";
    rf.receiver_type = "http.server.SimpleHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.SimpleHTTPRequestHandler.guess_type";
    rf.short_name = "guess_type";
    rf.receiver_type = "http.server.SimpleHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_519[] = { "do_POST", "is_cgi", "is_executable", "is_python", "run_cgi", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.server.CGIHTTPRequestHandler";
    rt.short_name = "CGIHTTPRequestHandler";
    rt.method_names = py_methods_519;
    static const char* py_bases_520[] = { "http.server.SimpleHTTPRequestHandler", NULL };
    rt.embedded_types = py_bases_520;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.CGIHTTPRequestHandler.do_POST";
    rf.short_name = "do_POST";
    rf.receiver_type = "http.server.CGIHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.CGIHTTPRequestHandler.is_cgi";
    rf.short_name = "is_cgi";
    rf.receiver_type = "http.server.CGIHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.CGIHTTPRequestHandler.is_executable";
    rf.short_name = "is_executable";
    rf.receiver_type = "http.server.CGIHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.CGIHTTPRequestHandler.is_python";
    rf.short_name = "is_python";
    rf.receiver_type = "http.server.CGIHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.CGIHTTPRequestHandler.run_cgi";
    rf.short_name = "run_cgi";
    rf.receiver_type = "http.server.CGIHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_521[] = { "do_POST", "is_cgi", "is_executable", "is_python", "run_cgi", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "http.server.CGIHTTPRequestHandler";
    rt.short_name = "CGIHTTPRequestHandler";
    rt.method_names = py_methods_521;
    static const char* py_bases_522[] = { "http.server.SimpleHTTPRequestHandler", NULL };
    rt.embedded_types = py_bases_522;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.CGIHTTPRequestHandler.do_POST";
    rf.short_name = "do_POST";
    rf.receiver_type = "http.server.CGIHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.CGIHTTPRequestHandler.is_cgi";
    rf.short_name = "is_cgi";
    rf.receiver_type = "http.server.CGIHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.CGIHTTPRequestHandler.is_executable";
    rf.short_name = "is_executable";
    rf.receiver_type = "http.server.CGIHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.CGIHTTPRequestHandler.is_python";
    rf.short_name = "is_python";
    rf.receiver_type = "http.server.CGIHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.CGIHTTPRequestHandler.run_cgi";
    rf.short_name = "run_cgi";
    rf.receiver_type = "http.server.CGIHTTPRequestHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "http.server.executable";
    rf.short_name = "executable";
    cbm_registry_add_func(reg, rf);

    /* ===== module: inspect ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect.EndOfBlock";
    rt.short_name = "EndOfBlock";
    static const char* py_bases_523[] = { "inspect.Exception", NULL };
    rt.embedded_types = py_bases_523;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_524[] = { "tokeneater", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect.BlockFinder";
    rt.short_name = "BlockFinder";
    rt.method_names = py_methods_524;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.BlockFinder.tokeneater";
    rf.short_name = "tokeneater";
    rf.receiver_type = "inspect.BlockFinder";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect._SupportsSet";
    rt.short_name = "_SupportsSet";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect._SupportsDelete";
    rt.short_name = "_SupportsDelete";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect._void";
    rt.short_name = "_void";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect._empty";
    rt.short_name = "_empty";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_525[] = { "__init__", "parameters", "return_annotation", "bind", "bind_partial", "replace", "from_callable", "format", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect.Signature";
    rt.short_name = "Signature";
    rt.method_names = py_methods_525;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.Signature.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "inspect.Signature";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.Signature.parameters";
    rf.short_name = "parameters";
    rf.receiver_type = "inspect.Signature";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.Signature.return_annotation";
    rf.short_name = "return_annotation";
    rf.receiver_type = "inspect.Signature";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.Signature.bind";
    rf.short_name = "bind";
    rf.receiver_type = "inspect.Signature";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.Signature.bind_partial";
    rf.short_name = "bind_partial";
    rf.receiver_type = "inspect.Signature";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.Signature.replace";
    rf.short_name = "replace";
    rf.receiver_type = "inspect.Signature";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.Signature.from_callable";
    rf.short_name = "from_callable";
    rf.receiver_type = "inspect.Signature";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.Signature.format";
    rf.short_name = "format";
    rf.receiver_type = "inspect.Signature";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_526[] = { "description", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect._ParameterKind";
    rt.short_name = "_ParameterKind";
    rt.method_names = py_methods_526;
    static const char* py_bases_527[] = { "enum.IntEnum", NULL };
    rt.embedded_types = py_bases_527;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect._ParameterKind.description";
    rf.short_name = "description";
    rf.receiver_type = "inspect._ParameterKind";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_528[] = { "__init__", "name", "default", "kind", "annotation", "replace", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect.Parameter";
    rt.short_name = "Parameter";
    rt.method_names = py_methods_528;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.Parameter.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "inspect.Parameter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.Parameter.name";
    rf.short_name = "name";
    rf.receiver_type = "inspect.Parameter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.Parameter.default";
    rf.short_name = "default";
    rf.receiver_type = "inspect.Parameter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.Parameter.kind";
    rf.short_name = "kind";
    rf.receiver_type = "inspect.Parameter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.Parameter.annotation";
    rf.short_name = "annotation";
    rf.receiver_type = "inspect.Parameter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.Parameter.replace";
    rf.short_name = "replace";
    rf.receiver_type = "inspect.Parameter";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_529[] = { "args", "kwargs", "signature", "__init__", "apply_defaults", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect.BoundArguments";
    rt.short_name = "BoundArguments";
    rt.method_names = py_methods_529;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.BoundArguments.args";
    rf.short_name = "args";
    rf.receiver_type = "inspect.BoundArguments";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.BoundArguments.kwargs";
    rf.short_name = "kwargs";
    rf.receiver_type = "inspect.BoundArguments";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.BoundArguments.signature";
    rf.short_name = "signature";
    rf.receiver_type = "inspect.BoundArguments";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.BoundArguments.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "inspect.BoundArguments";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.BoundArguments.apply_defaults";
    rf.short_name = "apply_defaults";
    rf.receiver_type = "inspect.BoundArguments";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect.Arguments";
    rt.short_name = "Arguments";
    static const char* py_bases_530[] = { "inspect.NamedTuple", NULL };
    rt.embedded_types = py_bases_530;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect.ArgSpec";
    rt.short_name = "ArgSpec";
    static const char* py_bases_531[] = { "inspect.NamedTuple", NULL };
    rt.embedded_types = py_bases_531;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect.FullArgSpec";
    rt.short_name = "FullArgSpec";
    static const char* py_bases_532[] = { "inspect.NamedTuple", NULL };
    rt.embedded_types = py_bases_532;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect.ArgInfo";
    rt.short_name = "ArgInfo";
    static const char* py_bases_533[] = { "inspect.NamedTuple", NULL };
    rt.embedded_types = py_bases_533;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect.ClosureVars";
    rt.short_name = "ClosureVars";
    static const char* py_bases_534[] = { "inspect.NamedTuple", NULL };
    rt.embedded_types = py_bases_534;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect._Traceback";
    rt.short_name = "_Traceback";
    static const char* py_bases_535[] = { "inspect.NamedTuple", NULL };
    rt.embedded_types = py_bases_535;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect._FrameInfo";
    rt.short_name = "_FrameInfo";
    static const char* py_bases_536[] = { "inspect.NamedTuple", NULL };
    rt.embedded_types = py_bases_536;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect.Traceback";
    rt.short_name = "Traceback";
    static const char* py_bases_537[] = { "inspect._Traceback", NULL };
    rt.embedded_types = py_bases_537;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect.FrameInfo";
    rt.short_name = "FrameInfo";
    static const char* py_bases_538[] = { "inspect._FrameInfo", NULL };
    rt.embedded_types = py_bases_538;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect.Traceback";
    rt.short_name = "Traceback";
    static const char* py_bases_539[] = { "inspect._Traceback", NULL };
    rt.embedded_types = py_bases_539;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect.FrameInfo";
    rt.short_name = "FrameInfo";
    static const char* py_bases_540[] = { "inspect._FrameInfo", NULL };
    rt.embedded_types = py_bases_540;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect.Traceback";
    rt.short_name = "Traceback";
    static const char* py_bases_541[] = { "inspect.NamedTuple", NULL };
    rt.embedded_types = py_bases_541;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect.FrameInfo";
    rt.short_name = "FrameInfo";
    static const char* py_bases_542[] = { "inspect.NamedTuple", NULL };
    rt.embedded_types = py_bases_542;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect.Attribute";
    rt.short_name = "Attribute";
    static const char* py_bases_543[] = { "inspect.NamedTuple", NULL };
    rt.embedded_types = py_bases_543;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect.ClassFoundException";
    rt.short_name = "ClassFoundException";
    static const char* py_bases_544[] = { "inspect.Exception", NULL };
    rt.embedded_types = py_bases_544;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "inspect.BufferFlags";
    rt.short_name = "BufferFlags";
    static const char* py_bases_545[] = { "enum.IntFlag", NULL };
    rt.embedded_types = py_bases_545;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getmembers";
    rf.short_name = "getmembers";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getmembers_static";
    rf.short_name = "getmembers_static";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getmodulename";
    rf.short_name = "getmodulename";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.ismodule";
    rf.short_name = "ismodule";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.isclass";
    rf.short_name = "isclass";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.ismethod";
    rf.short_name = "ismethod";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.ispackage";
    rf.short_name = "ispackage";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.isfunction";
    rf.short_name = "isfunction";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.markcoroutinefunction";
    rf.short_name = "markcoroutinefunction";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.isgeneratorfunction";
    rf.short_name = "isgeneratorfunction";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.iscoroutinefunction";
    rf.short_name = "iscoroutinefunction";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.isgenerator";
    rf.short_name = "isgenerator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.iscoroutine";
    rf.short_name = "iscoroutine";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.isawaitable";
    rf.short_name = "isawaitable";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.isasyncgenfunction";
    rf.short_name = "isasyncgenfunction";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.isasyncgen";
    rf.short_name = "isasyncgen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.istraceback";
    rf.short_name = "istraceback";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.isframe";
    rf.short_name = "isframe";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.iscode";
    rf.short_name = "iscode";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.isbuiltin";
    rf.short_name = "isbuiltin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.ismethodwrapper";
    rf.short_name = "ismethodwrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.isroutine";
    rf.short_name = "isroutine";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.ismethoddescriptor";
    rf.short_name = "ismethoddescriptor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.ismemberdescriptor";
    rf.short_name = "ismemberdescriptor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.isabstract";
    rf.short_name = "isabstract";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.isgetsetdescriptor";
    rf.short_name = "isgetsetdescriptor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.isdatadescriptor";
    rf.short_name = "isdatadescriptor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.findsource";
    rf.short_name = "findsource";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getabsfile";
    rf.short_name = "getabsfile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getblock";
    rf.short_name = "getblock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getdoc";
    rf.short_name = "getdoc";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getcomments";
    rf.short_name = "getcomments";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getfile";
    rf.short_name = "getfile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getmodule";
    rf.short_name = "getmodule";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getsourcefile";
    rf.short_name = "getsourcefile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getsourcelines";
    rf.short_name = "getsourcelines";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getsource";
    rf.short_name = "getsource";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.cleandoc";
    rf.short_name = "cleandoc";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.indentsize";
    rf.short_name = "indentsize";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.signature";
    rf.short_name = "signature";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.get_annotations";
    rf.short_name = "get_annotations";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getasyncgenstate";
    rf.short_name = "getasyncgenstate";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getasyncgenlocals";
    rf.short_name = "getasyncgenlocals";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getclasstree";
    rf.short_name = "getclasstree";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.walktree";
    rf.short_name = "walktree";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getargs";
    rf.short_name = "getargs";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getargspec";
    rf.short_name = "getargspec";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getfullargspec";
    rf.short_name = "getfullargspec";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getargvalues";
    rf.short_name = "getargvalues";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.formatannotation";
    rf.short_name = "formatannotation";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.formatannotationrelativeto";
    rf.short_name = "formatannotationrelativeto";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.formatargspec";
    rf.short_name = "formatargspec";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.formatargvalues";
    rf.short_name = "formatargvalues";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getmro";
    rf.short_name = "getmro";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getcallargs";
    rf.short_name = "getcallargs";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getclosurevars";
    rf.short_name = "getclosurevars";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.unwrap";
    rf.short_name = "unwrap";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getframeinfo";
    rf.short_name = "getframeinfo";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getouterframes";
    rf.short_name = "getouterframes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getinnerframes";
    rf.short_name = "getinnerframes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getlineno";
    rf.short_name = "getlineno";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.currentframe";
    rf.short_name = "currentframe";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.stack";
    rf.short_name = "stack";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.trace";
    rf.short_name = "trace";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getattr_static";
    rf.short_name = "getattr_static";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getgeneratorstate";
    rf.short_name = "getgeneratorstate";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getcoroutinestate";
    rf.short_name = "getcoroutinestate";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getgeneratorlocals";
    rf.short_name = "getgeneratorlocals";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.getcoroutinelocals";
    rf.short_name = "getcoroutinelocals";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "inspect.classify_class_attrs";
    rf.short_name = "classify_class_attrs";
    cbm_registry_add_func(reg, rf);

    /* ===== module: io ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.UnsupportedOperation";
    rt.short_name = "UnsupportedOperation";
    static const char* py_bases_546[] = { "io.OSError", "io.ValueError", NULL };
    rt.embedded_types = py_bases_546;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.IOBase";
    rt.short_name = "IOBase";
    static const char* py_bases_547[] = { "io._IOBase", NULL };
    rt.embedded_types = py_bases_547;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.RawIOBase";
    rt.short_name = "RawIOBase";
    static const char* py_bases_548[] = { "io._RawIOBase", "io.IOBase", NULL };
    rt.embedded_types = py_bases_548;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.BufferedIOBase";
    rt.short_name = "BufferedIOBase";
    static const char* py_bases_549[] = { "io._BufferedIOBase", "io.IOBase", NULL };
    rt.embedded_types = py_bases_549;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.TextIOBase";
    rt.short_name = "TextIOBase";
    static const char* py_bases_550[] = { "io._TextIOBase", "io.IOBase", NULL };
    rt.embedded_types = py_bases_550;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_551[] = { "read", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.Reader";
    rt.short_name = "Reader";
    rt.method_names = py_methods_551;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.Reader.read";
    rf.short_name = "read";
    rf.receiver_type = "io.Reader";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_552[] = { "write", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.Writer";
    rt.short_name = "Writer";
    rt.method_names = py_methods_552;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.Writer.write";
    rf.short_name = "write";
    rf.receiver_type = "io.Writer";
    cbm_registry_add_func(reg, rf);

    /* ===== module: itertools ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "itertools.count";
    rt.short_name = "count";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "itertools.cycle";
    rt.short_name = "cycle";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "itertools.repeat";
    rt.short_name = "repeat";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "itertools.accumulate";
    rt.short_name = "accumulate";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_553[] = { "from_iterable", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "itertools.chain";
    rt.short_name = "chain";
    rt.method_names = py_methods_553;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "itertools.chain.from_iterable";
    rf.short_name = "from_iterable";
    rf.receiver_type = "itertools.chain";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "itertools.compress";
    rt.short_name = "compress";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "itertools.dropwhile";
    rt.short_name = "dropwhile";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "itertools.filterfalse";
    rt.short_name = "filterfalse";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "itertools.groupby";
    rt.short_name = "groupby";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "itertools.islice";
    rt.short_name = "islice";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "itertools.starmap";
    rt.short_name = "starmap";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "itertools.takewhile";
    rt.short_name = "takewhile";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "itertools.zip_longest";
    rt.short_name = "zip_longest";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "itertools.product";
    rt.short_name = "product";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "itertools.permutations";
    rt.short_name = "permutations";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "itertools.combinations";
    rt.short_name = "combinations";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "itertools.combinations_with_replacement";
    rt.short_name = "combinations_with_replacement";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "itertools.pairwise";
    rt.short_name = "pairwise";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_554[] = { "__new__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "itertools.batched";
    rt.short_name = "batched";
    rt.method_names = py_methods_554;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "itertools.batched.__new__";
    rf.short_name = "__new__";
    rf.receiver_type = "itertools.batched";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "itertools.tee";
    rf.short_name = "tee";
    cbm_registry_add_func(reg, rf);

    /* ===== module: json ===== */
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "json.dumps";
    rf.short_name = "dumps";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "json.dump";
    rf.short_name = "dump";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "json.loads";
    rf.short_name = "loads";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "json.load";
    rf.short_name = "load";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "json.detect_encoding";
    rf.short_name = "detect_encoding";
    cbm_registry_add_func(reg, rf);

    /* ===== module: json.decoder ===== */
    static const char* py_methods_555[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "json.decoder.JSONDecodeError";
    rt.short_name = "JSONDecodeError";
    rt.method_names = py_methods_555;
    static const char* py_bases_556[] = { "json.decoder.ValueError", NULL };
    rt.embedded_types = py_bases_556;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "json.decoder.JSONDecodeError.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "json.decoder.JSONDecodeError";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_557[] = { "__init__", "decode", "raw_decode", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "json.decoder.JSONDecoder";
    rt.short_name = "JSONDecoder";
    rt.method_names = py_methods_557;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "json.decoder.JSONDecoder.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "json.decoder.JSONDecoder";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "json.decoder.JSONDecoder.decode";
    rf.short_name = "decode";
    rf.receiver_type = "json.decoder.JSONDecoder";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "json.decoder.JSONDecoder.raw_decode";
    rf.short_name = "raw_decode";
    rf.receiver_type = "json.decoder.JSONDecoder";
    cbm_registry_add_func(reg, rf);

    /* ===== module: json.encoder ===== */
    static const char* py_methods_558[] = { "__init__", "default", "encode", "iterencode", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "json.encoder.JSONEncoder";
    rt.short_name = "JSONEncoder";
    rt.method_names = py_methods_558;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "json.encoder.JSONEncoder.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "json.encoder.JSONEncoder";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "json.encoder.JSONEncoder.default";
    rf.short_name = "default";
    rf.receiver_type = "json.encoder.JSONEncoder";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "json.encoder.JSONEncoder.encode";
    rf.short_name = "encode";
    rf.receiver_type = "json.encoder.JSONEncoder";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "json.encoder.JSONEncoder.iterencode";
    rf.short_name = "iterencode";
    rf.receiver_type = "json.encoder.JSONEncoder";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "json.encoder.py_encode_basestring";
    rf.short_name = "py_encode_basestring";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "json.encoder.py_encode_basestring_ascii";
    rf.short_name = "py_encode_basestring_ascii";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "json.encoder.encode_basestring";
    rf.short_name = "encode_basestring";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "json.encoder.encode_basestring_ascii";
    rf.short_name = "encode_basestring_ascii";
    cbm_registry_add_func(reg, rf);

    /* ===== module: json.tool ===== */
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "json.tool.main";
    rf.short_name = "main";
    cbm_registry_add_func(reg, rf);

    /* ===== module: logging ===== */
    static const char* py_methods_559[] = { "filter", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging._SupportsFilter";
    rt.short_name = "_SupportsFilter";
    rt.method_names = py_methods_559;
    static const char* py_bases_560[] = { "logging.Protocol", NULL };
    rt.embedded_types = py_bases_560;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging._SupportsFilter.filter";
    rf.short_name = "filter";
    rf.receiver_type = "logging._SupportsFilter";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_561[] = { "filter", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging._SupportsFilter";
    rt.short_name = "_SupportsFilter";
    rt.method_names = py_methods_561;
    static const char* py_bases_562[] = { "logging.Protocol", NULL };
    rt.embedded_types = py_bases_562;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging._SupportsFilter.filter";
    rf.short_name = "filter";
    rf.receiver_type = "logging._SupportsFilter";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_563[] = { "addFilter", "removeFilter", "filter", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.Filterer";
    rt.short_name = "Filterer";
    rt.method_names = py_methods_563;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Filterer.addFilter";
    rf.short_name = "addFilter";
    rf.receiver_type = "logging.Filterer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Filterer.removeFilter";
    rf.short_name = "removeFilter";
    rf.receiver_type = "logging.Filterer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Filterer.filter";
    rf.short_name = "filter";
    rf.receiver_type = "logging.Filterer";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_564[] = { "__init__", "getLogger", "setLoggerClass", "setLogRecordFactory", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.Manager";
    rt.short_name = "Manager";
    rt.method_names = py_methods_564;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Manager.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.Manager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Manager.getLogger";
    rf.short_name = "getLogger";
    rf.receiver_type = "logging.Manager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Manager.setLoggerClass";
    rf.short_name = "setLoggerClass";
    rf.receiver_type = "logging.Manager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Manager.setLogRecordFactory";
    rf.short_name = "setLogRecordFactory";
    rf.receiver_type = "logging.Manager";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_565[] = { "__init__", "setLevel", "isEnabledFor", "getEffectiveLevel", "getChild", "getChildren", "debug", "info", "warning", "warn", "error", "exception", "critical", "log", "addHandler", "removeHandler", "findCaller", "handle", "makeRecord", "hasHandlers", "callHandlers", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.Logger";
    rt.short_name = "Logger";
    rt.method_names = py_methods_565;
    static const char* py_bases_566[] = { "logging.Filterer", NULL };
    rt.embedded_types = py_bases_566;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.setLevel";
    rf.short_name = "setLevel";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.isEnabledFor";
    rf.short_name = "isEnabledFor";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.getEffectiveLevel";
    rf.short_name = "getEffectiveLevel";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.getChild";
    rf.short_name = "getChild";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.getChildren";
    rf.short_name = "getChildren";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.debug";
    rf.short_name = "debug";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.info";
    rf.short_name = "info";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.warning";
    rf.short_name = "warning";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.warn";
    rf.short_name = "warn";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.error";
    rf.short_name = "error";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.exception";
    rf.short_name = "exception";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.critical";
    rf.short_name = "critical";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.log";
    rf.short_name = "log";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.addHandler";
    rf.short_name = "addHandler";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.removeHandler";
    rf.short_name = "removeHandler";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.findCaller";
    rf.short_name = "findCaller";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.handle";
    rf.short_name = "handle";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.makeRecord";
    rf.short_name = "makeRecord";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.hasHandlers";
    rf.short_name = "hasHandlers";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Logger.callHandlers";
    rf.short_name = "callHandlers";
    rf.receiver_type = "logging.Logger";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_567[] = { "__init__", "get_name", "set_name", "createLock", "acquire", "release", "setLevel", "setFormatter", "flush", "close", "handle", "handleError", "format", "emit", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.Handler";
    rt.short_name = "Handler";
    rt.method_names = py_methods_567;
    static const char* py_bases_568[] = { "logging.Filterer", NULL };
    rt.embedded_types = py_bases_568;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Handler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.Handler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Handler.get_name";
    rf.short_name = "get_name";
    rf.receiver_type = "logging.Handler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Handler.set_name";
    rf.short_name = "set_name";
    rf.receiver_type = "logging.Handler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Handler.createLock";
    rf.short_name = "createLock";
    rf.receiver_type = "logging.Handler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Handler.acquire";
    rf.short_name = "acquire";
    rf.receiver_type = "logging.Handler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Handler.release";
    rf.short_name = "release";
    rf.receiver_type = "logging.Handler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Handler.setLevel";
    rf.short_name = "setLevel";
    rf.receiver_type = "logging.Handler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Handler.setFormatter";
    rf.short_name = "setFormatter";
    rf.receiver_type = "logging.Handler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Handler.flush";
    rf.short_name = "flush";
    rf.receiver_type = "logging.Handler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Handler.close";
    rf.short_name = "close";
    rf.receiver_type = "logging.Handler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Handler.handle";
    rf.short_name = "handle";
    rf.receiver_type = "logging.Handler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Handler.handleError";
    rf.short_name = "handleError";
    rf.receiver_type = "logging.Handler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Handler.format";
    rf.short_name = "format";
    rf.receiver_type = "logging.Handler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Handler.emit";
    rf.short_name = "emit";
    rf.receiver_type = "logging.Handler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_569[] = { "__init__", "format", "formatTime", "formatException", "formatMessage", "formatStack", "usesTime", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.Formatter";
    rt.short_name = "Formatter";
    rt.method_names = py_methods_569;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Formatter.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.Formatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Formatter.format";
    rf.short_name = "format";
    rf.receiver_type = "logging.Formatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Formatter.formatTime";
    rf.short_name = "formatTime";
    rf.receiver_type = "logging.Formatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Formatter.formatException";
    rf.short_name = "formatException";
    rf.receiver_type = "logging.Formatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Formatter.formatMessage";
    rf.short_name = "formatMessage";
    rf.receiver_type = "logging.Formatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Formatter.formatStack";
    rf.short_name = "formatStack";
    rf.receiver_type = "logging.Formatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Formatter.usesTime";
    rf.short_name = "usesTime";
    rf.receiver_type = "logging.Formatter";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_570[] = { "__init__", "formatHeader", "formatFooter", "format", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.BufferingFormatter";
    rt.short_name = "BufferingFormatter";
    rt.method_names = py_methods_570;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.BufferingFormatter.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.BufferingFormatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.BufferingFormatter.formatHeader";
    rf.short_name = "formatHeader";
    rf.receiver_type = "logging.BufferingFormatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.BufferingFormatter.formatFooter";
    rf.short_name = "formatFooter";
    rf.receiver_type = "logging.BufferingFormatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.BufferingFormatter.format";
    rf.short_name = "format";
    rf.receiver_type = "logging.BufferingFormatter";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_571[] = { "__init__", "filter", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.Filter";
    rt.short_name = "Filter";
    rt.method_names = py_methods_571;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Filter.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.Filter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.Filter.filter";
    rf.short_name = "filter";
    rf.receiver_type = "logging.Filter";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_572[] = { "__init__", "getMessage", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.LogRecord";
    rt.short_name = "LogRecord";
    rt.method_names = py_methods_572;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.LogRecord.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.LogRecord";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.LogRecord.getMessage";
    rf.short_name = "getMessage";
    rf.receiver_type = "logging.LogRecord";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_573[] = { "__init__", "process", "debug", "info", "warning", "warn", "error", "exception", "critical", "log", "isEnabledFor", "getEffectiveLevel", "setLevel", "hasHandlers", "_log", "name", "__class_getitem__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.LoggerAdapter";
    rt.short_name = "LoggerAdapter";
    rt.method_names = py_methods_573;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.LoggerAdapter.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.LoggerAdapter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.LoggerAdapter.process";
    rf.short_name = "process";
    rf.receiver_type = "logging.LoggerAdapter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.LoggerAdapter.debug";
    rf.short_name = "debug";
    rf.receiver_type = "logging.LoggerAdapter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.LoggerAdapter.info";
    rf.short_name = "info";
    rf.receiver_type = "logging.LoggerAdapter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.LoggerAdapter.warning";
    rf.short_name = "warning";
    rf.receiver_type = "logging.LoggerAdapter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.LoggerAdapter.warn";
    rf.short_name = "warn";
    rf.receiver_type = "logging.LoggerAdapter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.LoggerAdapter.error";
    rf.short_name = "error";
    rf.receiver_type = "logging.LoggerAdapter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.LoggerAdapter.exception";
    rf.short_name = "exception";
    rf.receiver_type = "logging.LoggerAdapter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.LoggerAdapter.critical";
    rf.short_name = "critical";
    rf.receiver_type = "logging.LoggerAdapter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.LoggerAdapter.log";
    rf.short_name = "log";
    rf.receiver_type = "logging.LoggerAdapter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.LoggerAdapter.isEnabledFor";
    rf.short_name = "isEnabledFor";
    rf.receiver_type = "logging.LoggerAdapter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.LoggerAdapter.getEffectiveLevel";
    rf.short_name = "getEffectiveLevel";
    rf.receiver_type = "logging.LoggerAdapter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.LoggerAdapter.setLevel";
    rf.short_name = "setLevel";
    rf.receiver_type = "logging.LoggerAdapter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.LoggerAdapter.hasHandlers";
    rf.short_name = "hasHandlers";
    rf.receiver_type = "logging.LoggerAdapter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.LoggerAdapter._log";
    rf.short_name = "_log";
    rf.receiver_type = "logging.LoggerAdapter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.LoggerAdapter.name";
    rf.short_name = "name";
    rf.receiver_type = "logging.LoggerAdapter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.LoggerAdapter.__class_getitem__";
    rf.short_name = "__class_getitem__";
    rf.receiver_type = "logging.LoggerAdapter";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_574[] = { "__init__", "setStream", "__class_getitem__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.StreamHandler";
    rt.short_name = "StreamHandler";
    rt.method_names = py_methods_574;
    static const char* py_bases_575[] = { "logging.Handler", NULL };
    rt.embedded_types = py_bases_575;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.StreamHandler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.StreamHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.StreamHandler.setStream";
    rf.short_name = "setStream";
    rf.receiver_type = "logging.StreamHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.StreamHandler.__class_getitem__";
    rf.short_name = "__class_getitem__";
    rf.receiver_type = "logging.StreamHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_576[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.FileHandler";
    rt.short_name = "FileHandler";
    rt.method_names = py_methods_576;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.FileHandler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.FileHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.NullHandler";
    rt.short_name = "NullHandler";
    static const char* py_bases_577[] = { "logging.Handler", NULL };
    rt.embedded_types = py_bases_577;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_578[] = { "__init__", "append", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.PlaceHolder";
    rt.short_name = "PlaceHolder";
    rt.method_names = py_methods_578;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.PlaceHolder.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.PlaceHolder";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.PlaceHolder.append";
    rf.short_name = "append";
    rf.receiver_type = "logging.PlaceHolder";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_579[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.RootLogger";
    rt.short_name = "RootLogger";
    rt.method_names = py_methods_579;
    static const char* py_bases_580[] = { "logging.Logger", NULL };
    rt.embedded_types = py_bases_580;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.RootLogger.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.RootLogger";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_581[] = { "__init__", "usesTime", "validate", "format", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.PercentStyle";
    rt.short_name = "PercentStyle";
    rt.method_names = py_methods_581;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.PercentStyle.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.PercentStyle";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.PercentStyle.usesTime";
    rf.short_name = "usesTime";
    rf.receiver_type = "logging.PercentStyle";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.PercentStyle.validate";
    rf.short_name = "validate";
    rf.receiver_type = "logging.PercentStyle";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.PercentStyle.format";
    rf.short_name = "format";
    rf.receiver_type = "logging.PercentStyle";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.StrFormatStyle";
    rt.short_name = "StrFormatStyle";
    static const char* py_bases_582[] = { "logging.PercentStyle", NULL };
    rt.embedded_types = py_bases_582;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.StringTemplateStyle";
    rt.short_name = "StringTemplateStyle";
    static const char* py_bases_583[] = { "logging.PercentStyle", NULL };
    rt.embedded_types = py_bases_583;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.currentframe";
    rf.short_name = "currentframe";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.getHandlerByName";
    rf.short_name = "getHandlerByName";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.getHandlerNames";
    rf.short_name = "getHandlerNames";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.getLogger";
    rf.short_name = "getLogger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.getLoggerClass";
    rf.short_name = "getLoggerClass";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.getLogRecordFactory";
    rf.short_name = "getLogRecordFactory";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.debug";
    rf.short_name = "debug";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.info";
    rf.short_name = "info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.warning";
    rf.short_name = "warning";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.warn";
    rf.short_name = "warn";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.error";
    rf.short_name = "error";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.critical";
    rf.short_name = "critical";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.exception";
    rf.short_name = "exception";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.log";
    rf.short_name = "log";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.disable";
    rf.short_name = "disable";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.addLevelName";
    rf.short_name = "addLevelName";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.getLevelName";
    rf.short_name = "getLevelName";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.getLevelNamesMapping";
    rf.short_name = "getLevelNamesMapping";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.makeLogRecord";
    rf.short_name = "makeLogRecord";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.basicConfig";
    rf.short_name = "basicConfig";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.shutdown";
    rf.short_name = "shutdown";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.setLoggerClass";
    rf.short_name = "setLoggerClass";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.captureWarnings";
    rf.short_name = "captureWarnings";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.setLogRecordFactory";
    rf.short_name = "setLogRecordFactory";
    cbm_registry_add_func(reg, rf);

    /* ===== module: logging.config ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.config._RootLoggerConfiguration";
    rt.short_name = "_RootLoggerConfiguration";
    static const char* py_bases_584[] = { "logging.config.TypedDict", NULL };
    rt.embedded_types = py_bases_584;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.config._RootLoggerConfiguration";
    rt.short_name = "_RootLoggerConfiguration";
    static const char* py_bases_585[] = { "logging.config.TypedDict", NULL };
    rt.embedded_types = py_bases_585;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.config._LoggerConfiguration";
    rt.short_name = "_LoggerConfiguration";
    static const char* py_bases_586[] = { "logging.config._RootLoggerConfiguration", "logging.config.TypedDict", NULL };
    rt.embedded_types = py_bases_586;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.config._FilterConfigurationTypedDict";
    rt.short_name = "_FilterConfigurationTypedDict";
    static const char* py_bases_587[] = { "logging.config.TypedDict", NULL };
    rt.embedded_types = py_bases_587;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.config._DictConfigArgs";
    rt.short_name = "_DictConfigArgs";
    static const char* py_bases_588[] = { "logging.config.TypedDict", NULL };
    rt.embedded_types = py_bases_588;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_589[] = { "convert_with_key", "convert", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.config.ConvertingMixin";
    rt.short_name = "ConvertingMixin";
    rt.method_names = py_methods_589;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.ConvertingMixin.convert_with_key";
    rf.short_name = "convert_with_key";
    rf.receiver_type = "logging.config.ConvertingMixin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.ConvertingMixin.convert";
    rf.short_name = "convert";
    rf.receiver_type = "logging.config.ConvertingMixin";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_590[] = { "get", "pop", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.config.ConvertingDict";
    rt.short_name = "ConvertingDict";
    rt.method_names = py_methods_590;
    static const char* py_bases_591[] = { "logging.config.ConvertingMixin", NULL };
    rt.embedded_types = py_bases_591;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.ConvertingDict.get";
    rf.short_name = "get";
    rf.receiver_type = "logging.config.ConvertingDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.ConvertingDict.pop";
    rf.short_name = "pop";
    rf.receiver_type = "logging.config.ConvertingDict";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_592[] = { "pop", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.config.ConvertingList";
    rt.short_name = "ConvertingList";
    rt.method_names = py_methods_592;
    static const char* py_bases_593[] = { "logging.config.ConvertingMixin", NULL };
    rt.embedded_types = py_bases_593;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.ConvertingList.pop";
    rf.short_name = "pop";
    rf.receiver_type = "logging.config.ConvertingList";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.config.ConvertingTuple";
    rt.short_name = "ConvertingTuple";
    static const char* py_bases_594[] = { "logging.config.ConvertingMixin", NULL };
    rt.embedded_types = py_bases_594;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.config.ConvertingTuple";
    rt.short_name = "ConvertingTuple";
    static const char* py_bases_595[] = { "logging.config.ConvertingMixin", NULL };
    rt.embedded_types = py_bases_595;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_596[] = { "__init__", "resolve", "ext_convert", "cfg_convert", "convert", "configure_custom", "as_tuple", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.config.BaseConfigurator";
    rt.short_name = "BaseConfigurator";
    rt.method_names = py_methods_596;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.BaseConfigurator.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.config.BaseConfigurator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.BaseConfigurator.resolve";
    rf.short_name = "resolve";
    rf.receiver_type = "logging.config.BaseConfigurator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.BaseConfigurator.ext_convert";
    rf.short_name = "ext_convert";
    rf.receiver_type = "logging.config.BaseConfigurator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.BaseConfigurator.cfg_convert";
    rf.short_name = "cfg_convert";
    rf.receiver_type = "logging.config.BaseConfigurator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.BaseConfigurator.convert";
    rf.short_name = "convert";
    rf.receiver_type = "logging.config.BaseConfigurator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.BaseConfigurator.configure_custom";
    rf.short_name = "configure_custom";
    rf.receiver_type = "logging.config.BaseConfigurator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.BaseConfigurator.as_tuple";
    rf.short_name = "as_tuple";
    rf.receiver_type = "logging.config.BaseConfigurator";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_597[] = { "configure", "configure_formatter", "configure_filter", "add_filters", "configure_handler", "add_handlers", "common_logger_config", "configure_logger", "configure_root", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.config.DictConfigurator";
    rt.short_name = "DictConfigurator";
    rt.method_names = py_methods_597;
    static const char* py_bases_598[] = { "logging.config.BaseConfigurator", NULL };
    rt.embedded_types = py_bases_598;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.DictConfigurator.configure";
    rf.short_name = "configure";
    rf.receiver_type = "logging.config.DictConfigurator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.DictConfigurator.configure_formatter";
    rf.short_name = "configure_formatter";
    rf.receiver_type = "logging.config.DictConfigurator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.DictConfigurator.configure_filter";
    rf.short_name = "configure_filter";
    rf.receiver_type = "logging.config.DictConfigurator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.DictConfigurator.add_filters";
    rf.short_name = "add_filters";
    rf.receiver_type = "logging.config.DictConfigurator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.DictConfigurator.configure_handler";
    rf.short_name = "configure_handler";
    rf.receiver_type = "logging.config.DictConfigurator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.DictConfigurator.add_handlers";
    rf.short_name = "add_handlers";
    rf.receiver_type = "logging.config.DictConfigurator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.DictConfigurator.common_logger_config";
    rf.short_name = "common_logger_config";
    rf.receiver_type = "logging.config.DictConfigurator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.DictConfigurator.configure_logger";
    rf.short_name = "configure_logger";
    rf.receiver_type = "logging.config.DictConfigurator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.DictConfigurator.configure_root";
    rf.short_name = "configure_root";
    rf.receiver_type = "logging.config.DictConfigurator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.dictConfig";
    rf.short_name = "dictConfig";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.fileConfig";
    rf.short_name = "fileConfig";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.valid_ident";
    rf.short_name = "valid_ident";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.listen";
    rf.short_name = "listen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.config.stopListening";
    rf.short_name = "stopListening";
    cbm_registry_add_func(reg, rf);

    /* ===== module: logging.handlers ===== */
    static const char* py_methods_599[] = { "__init__", "reopenIfNeeded", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.handlers.WatchedFileHandler";
    rt.short_name = "WatchedFileHandler";
    rt.method_names = py_methods_599;
    static const char* py_bases_600[] = { "logging.handlers.FileHandler", NULL };
    rt.embedded_types = py_bases_600;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.WatchedFileHandler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.handlers.WatchedFileHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.WatchedFileHandler.reopenIfNeeded";
    rf.short_name = "reopenIfNeeded";
    rf.receiver_type = "logging.handlers.WatchedFileHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_601[] = { "__init__", "rotation_filename", "rotate", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.handlers.BaseRotatingHandler";
    rt.short_name = "BaseRotatingHandler";
    rt.method_names = py_methods_601;
    static const char* py_bases_602[] = { "logging.handlers.FileHandler", NULL };
    rt.embedded_types = py_bases_602;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.BaseRotatingHandler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.handlers.BaseRotatingHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.BaseRotatingHandler.rotation_filename";
    rf.short_name = "rotation_filename";
    rf.receiver_type = "logging.handlers.BaseRotatingHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.BaseRotatingHandler.rotate";
    rf.short_name = "rotate";
    rf.receiver_type = "logging.handlers.BaseRotatingHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_603[] = { "__init__", "doRollover", "shouldRollover", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.handlers.RotatingFileHandler";
    rt.short_name = "RotatingFileHandler";
    rt.method_names = py_methods_603;
    static const char* py_bases_604[] = { "logging.handlers.BaseRotatingHandler", NULL };
    rt.embedded_types = py_bases_604;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.RotatingFileHandler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.handlers.RotatingFileHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.RotatingFileHandler.doRollover";
    rf.short_name = "doRollover";
    rf.receiver_type = "logging.handlers.RotatingFileHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.RotatingFileHandler.shouldRollover";
    rf.short_name = "shouldRollover";
    rf.receiver_type = "logging.handlers.RotatingFileHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_605[] = { "__init__", "doRollover", "shouldRollover", "computeRollover", "getFilesToDelete", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.handlers.TimedRotatingFileHandler";
    rt.short_name = "TimedRotatingFileHandler";
    rt.method_names = py_methods_605;
    static const char* py_bases_606[] = { "logging.handlers.BaseRotatingHandler", NULL };
    rt.embedded_types = py_bases_606;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.TimedRotatingFileHandler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.handlers.TimedRotatingFileHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.TimedRotatingFileHandler.doRollover";
    rf.short_name = "doRollover";
    rf.receiver_type = "logging.handlers.TimedRotatingFileHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.TimedRotatingFileHandler.shouldRollover";
    rf.short_name = "shouldRollover";
    rf.receiver_type = "logging.handlers.TimedRotatingFileHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.TimedRotatingFileHandler.computeRollover";
    rf.short_name = "computeRollover";
    rf.receiver_type = "logging.handlers.TimedRotatingFileHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.TimedRotatingFileHandler.getFilesToDelete";
    rf.short_name = "getFilesToDelete";
    rf.receiver_type = "logging.handlers.TimedRotatingFileHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_607[] = { "__init__", "makeSocket", "makePickle", "send", "createSocket", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.handlers.SocketHandler";
    rt.short_name = "SocketHandler";
    rt.method_names = py_methods_607;
    static const char* py_bases_608[] = { "logging.handlers.Handler", NULL };
    rt.embedded_types = py_bases_608;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.SocketHandler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.handlers.SocketHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.SocketHandler.makeSocket";
    rf.short_name = "makeSocket";
    rf.receiver_type = "logging.handlers.SocketHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.SocketHandler.makePickle";
    rf.short_name = "makePickle";
    rf.receiver_type = "logging.handlers.SocketHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.SocketHandler.send";
    rf.short_name = "send";
    rf.receiver_type = "logging.handlers.SocketHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.SocketHandler.createSocket";
    rf.short_name = "createSocket";
    rf.receiver_type = "logging.handlers.SocketHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_609[] = { "makeSocket", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.handlers.DatagramHandler";
    rt.short_name = "DatagramHandler";
    rt.method_names = py_methods_609;
    static const char* py_bases_610[] = { "logging.handlers.SocketHandler", NULL };
    rt.embedded_types = py_bases_610;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.DatagramHandler.makeSocket";
    rf.short_name = "makeSocket";
    rf.receiver_type = "logging.handlers.DatagramHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_611[] = { "__init__", "createSocket", "encodePriority", "mapPriority", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.handlers.SysLogHandler";
    rt.short_name = "SysLogHandler";
    rt.method_names = py_methods_611;
    static const char* py_bases_612[] = { "logging.handlers.Handler", NULL };
    rt.embedded_types = py_bases_612;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.SysLogHandler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.handlers.SysLogHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.SysLogHandler.createSocket";
    rf.short_name = "createSocket";
    rf.receiver_type = "logging.handlers.SysLogHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.SysLogHandler.encodePriority";
    rf.short_name = "encodePriority";
    rf.receiver_type = "logging.handlers.SysLogHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.SysLogHandler.mapPriority";
    rf.short_name = "mapPriority";
    rf.receiver_type = "logging.handlers.SysLogHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_613[] = { "__init__", "getEventCategory", "getEventType", "getMessageID", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.handlers.NTEventLogHandler";
    rt.short_name = "NTEventLogHandler";
    rt.method_names = py_methods_613;
    static const char* py_bases_614[] = { "logging.handlers.Handler", NULL };
    rt.embedded_types = py_bases_614;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.NTEventLogHandler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.handlers.NTEventLogHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.NTEventLogHandler.getEventCategory";
    rf.short_name = "getEventCategory";
    rf.receiver_type = "logging.handlers.NTEventLogHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.NTEventLogHandler.getEventType";
    rf.short_name = "getEventType";
    rf.receiver_type = "logging.handlers.NTEventLogHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.NTEventLogHandler.getMessageID";
    rf.short_name = "getMessageID";
    rf.receiver_type = "logging.handlers.NTEventLogHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_615[] = { "__init__", "getSubject", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.handlers.SMTPHandler";
    rt.short_name = "SMTPHandler";
    rt.method_names = py_methods_615;
    static const char* py_bases_616[] = { "logging.handlers.Handler", NULL };
    rt.embedded_types = py_bases_616;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.SMTPHandler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.handlers.SMTPHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.SMTPHandler.getSubject";
    rf.short_name = "getSubject";
    rf.receiver_type = "logging.handlers.SMTPHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_617[] = { "__init__", "shouldFlush", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.handlers.BufferingHandler";
    rt.short_name = "BufferingHandler";
    rt.method_names = py_methods_617;
    static const char* py_bases_618[] = { "logging.handlers.Handler", NULL };
    rt.embedded_types = py_bases_618;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.BufferingHandler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.handlers.BufferingHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.BufferingHandler.shouldFlush";
    rf.short_name = "shouldFlush";
    rf.receiver_type = "logging.handlers.BufferingHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_619[] = { "__init__", "setTarget", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.handlers.MemoryHandler";
    rt.short_name = "MemoryHandler";
    rt.method_names = py_methods_619;
    static const char* py_bases_620[] = { "logging.handlers.BufferingHandler", NULL };
    rt.embedded_types = py_bases_620;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.MemoryHandler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.handlers.MemoryHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.MemoryHandler.setTarget";
    rf.short_name = "setTarget";
    rf.receiver_type = "logging.handlers.MemoryHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_621[] = { "__init__", "mapLogRecord", "getConnection", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.handlers.HTTPHandler";
    rt.short_name = "HTTPHandler";
    rt.method_names = py_methods_621;
    static const char* py_bases_622[] = { "logging.handlers.Handler", NULL };
    rt.embedded_types = py_bases_622;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.HTTPHandler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.handlers.HTTPHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.HTTPHandler.mapLogRecord";
    rf.short_name = "mapLogRecord";
    rf.receiver_type = "logging.handlers.HTTPHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.HTTPHandler.getConnection";
    rf.short_name = "getConnection";
    rf.receiver_type = "logging.handlers.HTTPHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_623[] = { "get", "put_nowait", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.handlers._QueueLike";
    rt.short_name = "_QueueLike";
    rt.method_names = py_methods_623;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers._QueueLike.get";
    rf.short_name = "get";
    rf.receiver_type = "logging.handlers._QueueLike";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers._QueueLike.put_nowait";
    rf.short_name = "put_nowait";
    rf.receiver_type = "logging.handlers._QueueLike";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_624[] = { "__init__", "prepare", "enqueue", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.handlers.QueueHandler";
    rt.short_name = "QueueHandler";
    rt.method_names = py_methods_624;
    static const char* py_bases_625[] = { "logging.handlers.Handler", NULL };
    rt.embedded_types = py_bases_625;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.QueueHandler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.handlers.QueueHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.QueueHandler.prepare";
    rf.short_name = "prepare";
    rf.receiver_type = "logging.handlers.QueueHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.QueueHandler.enqueue";
    rf.short_name = "enqueue";
    rf.receiver_type = "logging.handlers.QueueHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_626[] = { "__init__", "dequeue", "prepare", "start", "stop", "enqueue_sentinel", "handle", "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "logging.handlers.QueueListener";
    rt.short_name = "QueueListener";
    rt.method_names = py_methods_626;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.QueueListener.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "logging.handlers.QueueListener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.QueueListener.dequeue";
    rf.short_name = "dequeue";
    rf.receiver_type = "logging.handlers.QueueListener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.QueueListener.prepare";
    rf.short_name = "prepare";
    rf.receiver_type = "logging.handlers.QueueListener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.QueueListener.start";
    rf.short_name = "start";
    rf.receiver_type = "logging.handlers.QueueListener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.QueueListener.stop";
    rf.short_name = "stop";
    rf.receiver_type = "logging.handlers.QueueListener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.QueueListener.enqueue_sentinel";
    rf.short_name = "enqueue_sentinel";
    rf.receiver_type = "logging.handlers.QueueListener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.QueueListener.handle";
    rf.short_name = "handle";
    rf.receiver_type = "logging.handlers.QueueListener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.QueueListener.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "logging.handlers.QueueListener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "logging.handlers.QueueListener.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "logging.handlers.QueueListener";
    cbm_registry_add_func(reg, rf);

    /* ===== module: math ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "math._SupportsCeil";
    rt.short_name = "_SupportsCeil";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "math._SupportsFloor";
    rt.short_name = "_SupportsFloor";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "math._SupportsProdWithNoDefaultGiven";
    rt.short_name = "_SupportsProdWithNoDefaultGiven";
    static const char* py_bases_627[] = { "math.Protocol", NULL };
    rt.embedded_types = py_bases_627;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "math._SupportsTrunc";
    rt.short_name = "_SupportsTrunc";
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.acos";
    rf.short_name = "acos";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.acosh";
    rf.short_name = "acosh";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.asin";
    rf.short_name = "asin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.asinh";
    rf.short_name = "asinh";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.atan";
    rf.short_name = "atan";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.atan2";
    rf.short_name = "atan2";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.atanh";
    rf.short_name = "atanh";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.cbrt";
    rf.short_name = "cbrt";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.ceil";
    rf.short_name = "ceil";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.comb";
    rf.short_name = "comb";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.copysign";
    rf.short_name = "copysign";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.cos";
    rf.short_name = "cos";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.cosh";
    rf.short_name = "cosh";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.degrees";
    rf.short_name = "degrees";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.dist";
    rf.short_name = "dist";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.erf";
    rf.short_name = "erf";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.erfc";
    rf.short_name = "erfc";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.exp";
    rf.short_name = "exp";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.exp2";
    rf.short_name = "exp2";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.expm1";
    rf.short_name = "expm1";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.fabs";
    rf.short_name = "fabs";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.factorial";
    rf.short_name = "factorial";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.floor";
    rf.short_name = "floor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.fmod";
    rf.short_name = "fmod";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.frexp";
    rf.short_name = "frexp";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.fsum";
    rf.short_name = "fsum";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.gamma";
    rf.short_name = "gamma";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.gcd";
    rf.short_name = "gcd";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.hypot";
    rf.short_name = "hypot";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.isclose";
    rf.short_name = "isclose";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.isinf";
    rf.short_name = "isinf";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.isfinite";
    rf.short_name = "isfinite";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.isnan";
    rf.short_name = "isnan";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.isqrt";
    rf.short_name = "isqrt";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.lcm";
    rf.short_name = "lcm";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.ldexp";
    rf.short_name = "ldexp";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.lgamma";
    rf.short_name = "lgamma";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.log";
    rf.short_name = "log";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.log10";
    rf.short_name = "log10";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.log1p";
    rf.short_name = "log1p";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.log2";
    rf.short_name = "log2";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.modf";
    rf.short_name = "modf";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.nextafter";
    rf.short_name = "nextafter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.perm";
    rf.short_name = "perm";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.pow";
    rf.short_name = "pow";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.prod";
    rf.short_name = "prod";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.radians";
    rf.short_name = "radians";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.remainder";
    rf.short_name = "remainder";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.sin";
    rf.short_name = "sin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.sinh";
    rf.short_name = "sinh";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.sumprod";
    rf.short_name = "sumprod";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.sqrt";
    rf.short_name = "sqrt";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.tan";
    rf.short_name = "tan";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.tanh";
    rf.short_name = "tanh";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.trunc";
    rf.short_name = "trunc";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.ulp";
    rf.short_name = "ulp";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.fma";
    rf.short_name = "fma";
    cbm_registry_add_func(reg, rf);

    /* ===== module: multiprocessing.connection ===== */
    static const char* py_methods_628[] = { "__init__", "closed", "readable", "writable", "fileno", "close", "send_bytes", "send", "recv_bytes", "recv_bytes_into", "recv", "poll", "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.connection._ConnectionBase";
    rt.short_name = "_ConnectionBase";
    rt.method_names = py_methods_628;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection._ConnectionBase.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.connection._ConnectionBase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection._ConnectionBase.closed";
    rf.short_name = "closed";
    rf.receiver_type = "multiprocessing.connection._ConnectionBase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection._ConnectionBase.readable";
    rf.short_name = "readable";
    rf.receiver_type = "multiprocessing.connection._ConnectionBase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection._ConnectionBase.writable";
    rf.short_name = "writable";
    rf.receiver_type = "multiprocessing.connection._ConnectionBase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection._ConnectionBase.fileno";
    rf.short_name = "fileno";
    rf.receiver_type = "multiprocessing.connection._ConnectionBase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection._ConnectionBase.close";
    rf.short_name = "close";
    rf.receiver_type = "multiprocessing.connection._ConnectionBase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection._ConnectionBase.send_bytes";
    rf.short_name = "send_bytes";
    rf.receiver_type = "multiprocessing.connection._ConnectionBase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection._ConnectionBase.send";
    rf.short_name = "send";
    rf.receiver_type = "multiprocessing.connection._ConnectionBase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection._ConnectionBase.recv_bytes";
    rf.short_name = "recv_bytes";
    rf.receiver_type = "multiprocessing.connection._ConnectionBase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection._ConnectionBase.recv_bytes_into";
    rf.short_name = "recv_bytes_into";
    rf.receiver_type = "multiprocessing.connection._ConnectionBase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection._ConnectionBase.recv";
    rf.short_name = "recv";
    rf.receiver_type = "multiprocessing.connection._ConnectionBase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection._ConnectionBase.poll";
    rf.short_name = "poll";
    rf.receiver_type = "multiprocessing.connection._ConnectionBase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection._ConnectionBase.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "multiprocessing.connection._ConnectionBase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection._ConnectionBase.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "multiprocessing.connection._ConnectionBase";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.connection.Connection";
    rt.short_name = "Connection";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.connection.PipeConnection";
    rt.short_name = "PipeConnection";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_629[] = { "__init__", "accept", "close", "address", "last_accepted", "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.connection.Listener";
    rt.short_name = "Listener";
    rt.method_names = py_methods_629;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection.Listener.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.connection.Listener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection.Listener.accept";
    rf.short_name = "accept";
    rf.receiver_type = "multiprocessing.connection.Listener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection.Listener.close";
    rf.short_name = "close";
    rf.receiver_type = "multiprocessing.connection.Listener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection.Listener.address";
    rf.short_name = "address";
    rf.receiver_type = "multiprocessing.connection.Listener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection.Listener.last_accepted";
    rf.short_name = "last_accepted";
    rf.receiver_type = "multiprocessing.connection.Listener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection.Listener.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "multiprocessing.connection.Listener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection.Listener.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "multiprocessing.connection.Listener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection.deliver_challenge";
    rf.short_name = "deliver_challenge";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection.answer_challenge";
    rf.short_name = "answer_challenge";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection.wait";
    rf.short_name = "wait";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection.Client";
    rf.short_name = "Client";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.connection.Pipe";
    rf.short_name = "Pipe";
    cbm_registry_add_func(reg, rf);

    /* ===== module: multiprocessing.context ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.context.ProcessError";
    rt.short_name = "ProcessError";
    static const char* py_bases_630[] = { "multiprocessing.context.Exception", NULL };
    rt.embedded_types = py_bases_630;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.context.BufferTooShort";
    rt.short_name = "BufferTooShort";
    static const char* py_bases_631[] = { "multiprocessing.context.ProcessError", NULL };
    rt.embedded_types = py_bases_631;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.context.TimeoutError";
    rt.short_name = "TimeoutError";
    static const char* py_bases_632[] = { "multiprocessing.context.ProcessError", NULL };
    rt.embedded_types = py_bases_632;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.context.AuthenticationError";
    rt.short_name = "AuthenticationError";
    static const char* py_bases_633[] = { "multiprocessing.context.ProcessError", NULL };
    rt.embedded_types = py_bases_633;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_634[] = { "current_process", "parent_process", "active_children", "cpu_count", "Manager", "Pipe", "Barrier", "BoundedSemaphore", "Condition", "Event", "Lock", "RLock", "Semaphore", "Queue", "JoinableQueue", "SimpleQueue", "Pool", "RawValue", "RawArray", "Value", "Array", "freeze_support", "get_logger", "log_to_stderr", "allow_connection_pickling", "set_executable", "set_forkserver_preload", "get_context", "get_start_method", "set_start_method", "reducer", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.context.BaseContext";
    rt.short_name = "BaseContext";
    rt.method_names = py_methods_634;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.current_process";
    rf.short_name = "current_process";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.parent_process";
    rf.short_name = "parent_process";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.active_children";
    rf.short_name = "active_children";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.cpu_count";
    rf.short_name = "cpu_count";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.Manager";
    rf.short_name = "Manager";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.Pipe";
    rf.short_name = "Pipe";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.Barrier";
    rf.short_name = "Barrier";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.BoundedSemaphore";
    rf.short_name = "BoundedSemaphore";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.Condition";
    rf.short_name = "Condition";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.Event";
    rf.short_name = "Event";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.Lock";
    rf.short_name = "Lock";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.RLock";
    rf.short_name = "RLock";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.Semaphore";
    rf.short_name = "Semaphore";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.Queue";
    rf.short_name = "Queue";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.JoinableQueue";
    rf.short_name = "JoinableQueue";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.SimpleQueue";
    rf.short_name = "SimpleQueue";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.Pool";
    rf.short_name = "Pool";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.RawValue";
    rf.short_name = "RawValue";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.RawArray";
    rf.short_name = "RawArray";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.Value";
    rf.short_name = "Value";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.Array";
    rf.short_name = "Array";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.freeze_support";
    rf.short_name = "freeze_support";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.get_logger";
    rf.short_name = "get_logger";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.log_to_stderr";
    rf.short_name = "log_to_stderr";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.allow_connection_pickling";
    rf.short_name = "allow_connection_pickling";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.set_executable";
    rf.short_name = "set_executable";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.set_forkserver_preload";
    rf.short_name = "set_forkserver_preload";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.get_context";
    rf.short_name = "get_context";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.get_start_method";
    rf.short_name = "get_start_method";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.set_start_method";
    rf.short_name = "set_start_method";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.BaseContext.reducer";
    rf.short_name = "reducer";
    rf.receiver_type = "multiprocessing.context.BaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.context.Process";
    rt.short_name = "Process";
    static const char* py_bases_635[] = { "multiprocessing.context.BaseProcess", NULL };
    rt.embedded_types = py_bases_635;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_636[] = { "__init__", "get_start_method", "get_all_start_methods", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.context.DefaultContext";
    rt.short_name = "DefaultContext";
    rt.method_names = py_methods_636;
    static const char* py_bases_637[] = { "multiprocessing.context.BaseContext", NULL };
    rt.embedded_types = py_bases_637;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.DefaultContext.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.context.DefaultContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.DefaultContext.get_start_method";
    rf.short_name = "get_start_method";
    rf.receiver_type = "multiprocessing.context.DefaultContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.DefaultContext.get_all_start_methods";
    rf.short_name = "get_all_start_methods";
    rf.receiver_type = "multiprocessing.context.DefaultContext";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_638[] = { "_Popen", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.context.SpawnProcess";
    rt.short_name = "SpawnProcess";
    rt.method_names = py_methods_638;
    static const char* py_bases_639[] = { "multiprocessing.context.BaseProcess", NULL };
    rt.embedded_types = py_bases_639;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.SpawnProcess._Popen";
    rf.short_name = "_Popen";
    rf.receiver_type = "multiprocessing.context.SpawnProcess";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.context.SpawnContext";
    rt.short_name = "SpawnContext";
    static const char* py_bases_640[] = { "multiprocessing.context.BaseContext", NULL };
    rt.embedded_types = py_bases_640;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.context.ForkProcess";
    rt.short_name = "ForkProcess";
    static const char* py_bases_641[] = { "multiprocessing.context.BaseProcess", NULL };
    rt.embedded_types = py_bases_641;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.context.ForkServerProcess";
    rt.short_name = "ForkServerProcess";
    static const char* py_bases_642[] = { "multiprocessing.context.BaseProcess", NULL };
    rt.embedded_types = py_bases_642;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.context.ForkContext";
    rt.short_name = "ForkContext";
    static const char* py_bases_643[] = { "multiprocessing.context.BaseContext", NULL };
    rt.embedded_types = py_bases_643;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.context.ForkServerContext";
    rt.short_name = "ForkServerContext";
    static const char* py_bases_644[] = { "multiprocessing.context.BaseContext", NULL };
    rt.embedded_types = py_bases_644;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.get_spawning_popen";
    rf.short_name = "get_spawning_popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.set_spawning_popen";
    rf.short_name = "set_spawning_popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.context.assert_spawning";
    rf.short_name = "assert_spawning";
    cbm_registry_add_func(reg, rf);

    /* ===== module: multiprocessing.dummy ===== */
    static const char* py_methods_645[] = { "exitcode", "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.dummy.DummyProcess";
    rt.short_name = "DummyProcess";
    rt.method_names = py_methods_645;
    static const char* py_bases_646[] = { "threading.Thread", NULL };
    rt.embedded_types = py_bases_646;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.DummyProcess.exitcode";
    rf.short_name = "exitcode";
    rf.receiver_type = "multiprocessing.dummy.DummyProcess";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.DummyProcess.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.dummy.DummyProcess";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_647[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.dummy.Namespace";
    rt.short_name = "Namespace";
    rt.method_names = py_methods_647;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.Namespace.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.dummy.Namespace";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_648[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.dummy.Value";
    rt.short_name = "Value";
    rt.method_names = py_methods_648;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.Value.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.dummy.Value";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.Array";
    rf.short_name = "Array";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.Manager";
    rf.short_name = "Manager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.Pool";
    rf.short_name = "Pool";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.active_children";
    rf.short_name = "active_children";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.freeze_support";
    rf.short_name = "freeze_support";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.shutdown";
    rf.short_name = "shutdown";
    cbm_registry_add_func(reg, rf);

    /* ===== module: multiprocessing.dummy.connection ===== */
    static const char* py_methods_649[] = { "__enter__", "__exit__", "__init__", "close", "poll", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.dummy.connection.Connection";
    rt.short_name = "Connection";
    rt.method_names = py_methods_649;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.connection.Connection.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "multiprocessing.dummy.connection.Connection";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.connection.Connection.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "multiprocessing.dummy.connection.Connection";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.connection.Connection.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.dummy.connection.Connection";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.connection.Connection.close";
    rf.short_name = "close";
    rf.receiver_type = "multiprocessing.dummy.connection.Connection";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.connection.Connection.poll";
    rf.short_name = "poll";
    rf.receiver_type = "multiprocessing.dummy.connection.Connection";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_650[] = { "address", "__enter__", "__exit__", "__init__", "accept", "close", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.dummy.connection.Listener";
    rt.short_name = "Listener";
    rt.method_names = py_methods_650;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.connection.Listener.address";
    rf.short_name = "address";
    rf.receiver_type = "multiprocessing.dummy.connection.Listener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.connection.Listener.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "multiprocessing.dummy.connection.Listener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.connection.Listener.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "multiprocessing.dummy.connection.Listener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.connection.Listener.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.dummy.connection.Listener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.connection.Listener.accept";
    rf.short_name = "accept";
    rf.receiver_type = "multiprocessing.dummy.connection.Listener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.connection.Listener.close";
    rf.short_name = "close";
    rf.receiver_type = "multiprocessing.dummy.connection.Listener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.connection.Client";
    rf.short_name = "Client";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.dummy.connection.Pipe";
    rf.short_name = "Pipe";
    cbm_registry_add_func(reg, rf);

    /* ===== module: multiprocessing.forkserver ===== */
    static const char* py_methods_651[] = { "set_forkserver_preload", "get_inherited_fds", "connect_to_new_process", "ensure_running", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.forkserver.ForkServer";
    rt.short_name = "ForkServer";
    rt.method_names = py_methods_651;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.forkserver.ForkServer.set_forkserver_preload";
    rf.short_name = "set_forkserver_preload";
    rf.receiver_type = "multiprocessing.forkserver.ForkServer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.forkserver.ForkServer.get_inherited_fds";
    rf.short_name = "get_inherited_fds";
    rf.receiver_type = "multiprocessing.forkserver.ForkServer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.forkserver.ForkServer.connect_to_new_process";
    rf.short_name = "connect_to_new_process";
    rf.receiver_type = "multiprocessing.forkserver.ForkServer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.forkserver.ForkServer.ensure_running";
    rf.short_name = "ensure_running";
    rf.receiver_type = "multiprocessing.forkserver.ForkServer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.forkserver.main";
    rf.short_name = "main";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.forkserver.read_signed";
    rf.short_name = "read_signed";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.forkserver.write_signed";
    rf.short_name = "write_signed";
    cbm_registry_add_func(reg, rf);

    /* ===== module: multiprocessing.heap ===== */
    static const char* py_methods_652[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.heap.Arena";
    rt.short_name = "Arena";
    rt.method_names = py_methods_652;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.heap.Arena.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.heap.Arena";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_653[] = { "detach", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.heap._SupportsDetach";
    rt.short_name = "_SupportsDetach";
    rt.method_names = py_methods_653;
    static const char* py_bases_654[] = { "multiprocessing.heap.Protocol", NULL };
    rt.embedded_types = py_bases_654;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.heap._SupportsDetach.detach";
    rf.short_name = "detach";
    rf.receiver_type = "multiprocessing.heap._SupportsDetach";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_655[] = { "__init__", "free", "malloc", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.heap.Heap";
    rt.short_name = "Heap";
    rt.method_names = py_methods_655;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.heap.Heap.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.heap.Heap";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.heap.Heap.free";
    rf.short_name = "free";
    rf.receiver_type = "multiprocessing.heap.Heap";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.heap.Heap.malloc";
    rf.short_name = "malloc";
    rf.receiver_type = "multiprocessing.heap.Heap";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_656[] = { "__init__", "create_memoryview", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.heap.BufferWrapper";
    rt.short_name = "BufferWrapper";
    rt.method_names = py_methods_656;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.heap.BufferWrapper.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.heap.BufferWrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.heap.BufferWrapper.create_memoryview";
    rf.short_name = "create_memoryview";
    rf.receiver_type = "multiprocessing.heap.BufferWrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.heap.reduce_arena";
    rf.short_name = "reduce_arena";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.heap.rebuild_arena";
    rf.short_name = "rebuild_arena";
    cbm_registry_add_func(reg, rf);

    /* ===== module: multiprocessing.managers ===== */
    static const char* py_methods_657[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.managers.Namespace";
    rt.short_name = "Namespace";
    rt.method_names = py_methods_657;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.Namespace.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.managers.Namespace";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_658[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.managers.Token";
    rt.short_name = "Token";
    rt.method_names = py_methods_658;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.Token.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.managers.Token";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_659[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.managers.BaseProxy";
    rt.short_name = "BaseProxy";
    rt.method_names = py_methods_659;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.BaseProxy.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.managers.BaseProxy";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_660[] = { "get", "set", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.managers.ValueProxy";
    rt.short_name = "ValueProxy";
    rt.method_names = py_methods_660;
    static const char* py_bases_661[] = { "multiprocessing.managers.BaseProxy", NULL };
    rt.embedded_types = py_bases_661;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.ValueProxy.get";
    rf.short_name = "get";
    rf.receiver_type = "multiprocessing.managers.ValueProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.ValueProxy.set";
    rf.short_name = "set";
    rf.receiver_type = "multiprocessing.managers.ValueProxy";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_662[] = { "copy", "get", "pop", "keys", "items", "values", "fromkeys", "__reversed__", "__or__", "__ror__", "__ior__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.managers._BaseDictProxy";
    rt.short_name = "_BaseDictProxy";
    rt.method_names = py_methods_662;
    static const char* py_bases_663[] = { "multiprocessing.managers.BaseProxy", NULL };
    rt.embedded_types = py_bases_663;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseDictProxy.copy";
    rf.short_name = "copy";
    rf.receiver_type = "multiprocessing.managers._BaseDictProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseDictProxy.get";
    rf.short_name = "get";
    rf.receiver_type = "multiprocessing.managers._BaseDictProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseDictProxy.pop";
    rf.short_name = "pop";
    rf.receiver_type = "multiprocessing.managers._BaseDictProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseDictProxy.keys";
    rf.short_name = "keys";
    rf.receiver_type = "multiprocessing.managers._BaseDictProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseDictProxy.items";
    rf.short_name = "items";
    rf.receiver_type = "multiprocessing.managers._BaseDictProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseDictProxy.values";
    rf.short_name = "values";
    rf.receiver_type = "multiprocessing.managers._BaseDictProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseDictProxy.fromkeys";
    rf.short_name = "fromkeys";
    rf.receiver_type = "multiprocessing.managers._BaseDictProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseDictProxy.__reversed__";
    rf.short_name = "__reversed__";
    rf.receiver_type = "multiprocessing.managers._BaseDictProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseDictProxy.__or__";
    rf.short_name = "__or__";
    rf.receiver_type = "multiprocessing.managers._BaseDictProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseDictProxy.__ror__";
    rf.short_name = "__ror__";
    rf.receiver_type = "multiprocessing.managers._BaseDictProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseDictProxy.__ior__";
    rf.short_name = "__ior__";
    rf.receiver_type = "multiprocessing.managers._BaseDictProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.managers.DictProxy";
    rt.short_name = "DictProxy";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_664[] = { "copy", "get", "pop", "keys", "items", "values", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.managers.DictProxy";
    rt.short_name = "DictProxy";
    rt.method_names = py_methods_664;
    static const char* py_bases_665[] = { "multiprocessing.managers.BaseProxy", NULL };
    rt.embedded_types = py_bases_665;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.DictProxy.copy";
    rf.short_name = "copy";
    rf.receiver_type = "multiprocessing.managers.DictProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.DictProxy.get";
    rf.short_name = "get";
    rf.receiver_type = "multiprocessing.managers.DictProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.DictProxy.pop";
    rf.short_name = "pop";
    rf.receiver_type = "multiprocessing.managers.DictProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.DictProxy.keys";
    rf.short_name = "keys";
    rf.receiver_type = "multiprocessing.managers.DictProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.DictProxy.items";
    rf.short_name = "items";
    rf.receiver_type = "multiprocessing.managers.DictProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.DictProxy.values";
    rf.short_name = "values";
    rf.receiver_type = "multiprocessing.managers.DictProxy";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_666[] = { "add", "copy", "clear", "difference", "difference_update", "discard", "intersection", "intersection_update", "isdisjoint", "issubset", "issuperset", "pop", "remove", "symmetric_difference", "symmetric_difference_update", "union", "update", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.managers._BaseSetProxy";
    rt.short_name = "_BaseSetProxy";
    rt.method_names = py_methods_666;
    static const char* py_bases_667[] = { "multiprocessing.managers.BaseProxy", NULL };
    rt.embedded_types = py_bases_667;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseSetProxy.add";
    rf.short_name = "add";
    rf.receiver_type = "multiprocessing.managers._BaseSetProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseSetProxy.copy";
    rf.short_name = "copy";
    rf.receiver_type = "multiprocessing.managers._BaseSetProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseSetProxy.clear";
    rf.short_name = "clear";
    rf.receiver_type = "multiprocessing.managers._BaseSetProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseSetProxy.difference";
    rf.short_name = "difference";
    rf.receiver_type = "multiprocessing.managers._BaseSetProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseSetProxy.difference_update";
    rf.short_name = "difference_update";
    rf.receiver_type = "multiprocessing.managers._BaseSetProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseSetProxy.discard";
    rf.short_name = "discard";
    rf.receiver_type = "multiprocessing.managers._BaseSetProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseSetProxy.intersection";
    rf.short_name = "intersection";
    rf.receiver_type = "multiprocessing.managers._BaseSetProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseSetProxy.intersection_update";
    rf.short_name = "intersection_update";
    rf.receiver_type = "multiprocessing.managers._BaseSetProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseSetProxy.isdisjoint";
    rf.short_name = "isdisjoint";
    rf.receiver_type = "multiprocessing.managers._BaseSetProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseSetProxy.issubset";
    rf.short_name = "issubset";
    rf.receiver_type = "multiprocessing.managers._BaseSetProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseSetProxy.issuperset";
    rf.short_name = "issuperset";
    rf.receiver_type = "multiprocessing.managers._BaseSetProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseSetProxy.pop";
    rf.short_name = "pop";
    rf.receiver_type = "multiprocessing.managers._BaseSetProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseSetProxy.remove";
    rf.short_name = "remove";
    rf.receiver_type = "multiprocessing.managers._BaseSetProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseSetProxy.symmetric_difference";
    rf.short_name = "symmetric_difference";
    rf.receiver_type = "multiprocessing.managers._BaseSetProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseSetProxy.symmetric_difference_update";
    rf.short_name = "symmetric_difference_update";
    rf.receiver_type = "multiprocessing.managers._BaseSetProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseSetProxy.union";
    rf.short_name = "union";
    rf.receiver_type = "multiprocessing.managers._BaseSetProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers._BaseSetProxy.update";
    rf.short_name = "update";
    rf.receiver_type = "multiprocessing.managers._BaseSetProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.managers.SetProxy";
    rt.short_name = "SetProxy";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_668[] = { "append", "extend", "pop", "index", "count", "insert", "remove", "clear", "copy", "sort", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.managers.BaseListProxy";
    rt.short_name = "BaseListProxy";
    rt.method_names = py_methods_668;
    static const char* py_bases_669[] = { "multiprocessing.managers.BaseProxy", NULL };
    rt.embedded_types = py_bases_669;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.BaseListProxy.append";
    rf.short_name = "append";
    rf.receiver_type = "multiprocessing.managers.BaseListProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.BaseListProxy.extend";
    rf.short_name = "extend";
    rf.receiver_type = "multiprocessing.managers.BaseListProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.BaseListProxy.pop";
    rf.short_name = "pop";
    rf.receiver_type = "multiprocessing.managers.BaseListProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.BaseListProxy.index";
    rf.short_name = "index";
    rf.receiver_type = "multiprocessing.managers.BaseListProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.BaseListProxy.count";
    rf.short_name = "count";
    rf.receiver_type = "multiprocessing.managers.BaseListProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.BaseListProxy.insert";
    rf.short_name = "insert";
    rf.receiver_type = "multiprocessing.managers.BaseListProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.BaseListProxy.remove";
    rf.short_name = "remove";
    rf.receiver_type = "multiprocessing.managers.BaseListProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.BaseListProxy.clear";
    rf.short_name = "clear";
    rf.receiver_type = "multiprocessing.managers.BaseListProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.BaseListProxy.copy";
    rf.short_name = "copy";
    rf.receiver_type = "multiprocessing.managers.BaseListProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.BaseListProxy.sort";
    rf.short_name = "sort";
    rf.receiver_type = "multiprocessing.managers.BaseListProxy";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_670[] = { "__class_getitem__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.managers.ListProxy";
    rt.short_name = "ListProxy";
    rt.method_names = py_methods_670;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.ListProxy.__class_getitem__";
    rf.short_name = "__class_getitem__";
    rf.receiver_type = "multiprocessing.managers.ListProxy";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_671[] = { "__init__", "serve_forever", "accepter", "handle_request", "serve_client", "fallback_getvalue", "fallback_str", "fallback_repr", "dummy", "debug_info", "number_of_objects", "shutdown", "create", "get_methods", "accept_connection", "incref", "decref", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.managers.Server";
    rt.short_name = "Server";
    rt.method_names = py_methods_671;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.Server.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.managers.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.Server.serve_forever";
    rf.short_name = "serve_forever";
    rf.receiver_type = "multiprocessing.managers.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.Server.accepter";
    rf.short_name = "accepter";
    rf.receiver_type = "multiprocessing.managers.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.Server.handle_request";
    rf.short_name = "handle_request";
    rf.receiver_type = "multiprocessing.managers.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.Server.serve_client";
    rf.short_name = "serve_client";
    rf.receiver_type = "multiprocessing.managers.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.Server.fallback_getvalue";
    rf.short_name = "fallback_getvalue";
    rf.receiver_type = "multiprocessing.managers.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.Server.fallback_str";
    rf.short_name = "fallback_str";
    rf.receiver_type = "multiprocessing.managers.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.Server.fallback_repr";
    rf.short_name = "fallback_repr";
    rf.receiver_type = "multiprocessing.managers.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.Server.dummy";
    rf.short_name = "dummy";
    rf.receiver_type = "multiprocessing.managers.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.Server.debug_info";
    rf.short_name = "debug_info";
    rf.receiver_type = "multiprocessing.managers.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.Server.number_of_objects";
    rf.short_name = "number_of_objects";
    rf.receiver_type = "multiprocessing.managers.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.Server.shutdown";
    rf.short_name = "shutdown";
    rf.receiver_type = "multiprocessing.managers.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.Server.create";
    rf.short_name = "create";
    rf.receiver_type = "multiprocessing.managers.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.Server.get_methods";
    rf.short_name = "get_methods";
    rf.receiver_type = "multiprocessing.managers.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.Server.accept_connection";
    rf.short_name = "accept_connection";
    rf.receiver_type = "multiprocessing.managers.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.Server.incref";
    rf.short_name = "incref";
    rf.receiver_type = "multiprocessing.managers.Server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.Server.decref";
    rf.short_name = "decref";
    rf.receiver_type = "multiprocessing.managers.Server";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_672[] = { "__init__", "get_server", "connect", "start", "join", "address", "register", "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.managers.BaseManager";
    rt.short_name = "BaseManager";
    rt.method_names = py_methods_672;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.BaseManager.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.managers.BaseManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.BaseManager.get_server";
    rf.short_name = "get_server";
    rf.receiver_type = "multiprocessing.managers.BaseManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.BaseManager.connect";
    rf.short_name = "connect";
    rf.receiver_type = "multiprocessing.managers.BaseManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.BaseManager.start";
    rf.short_name = "start";
    rf.receiver_type = "multiprocessing.managers.BaseManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.BaseManager.join";
    rf.short_name = "join";
    rf.receiver_type = "multiprocessing.managers.BaseManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.BaseManager.address";
    rf.short_name = "address";
    rf.receiver_type = "multiprocessing.managers.BaseManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.BaseManager.register";
    rf.short_name = "register";
    rf.receiver_type = "multiprocessing.managers.BaseManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.BaseManager.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "multiprocessing.managers.BaseManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.BaseManager.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "multiprocessing.managers.BaseManager";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_673[] = { "Barrier", "BoundedSemaphore", "Condition", "Event", "Lock", "Namespace", "Pool", "Queue", "JoinableQueue", "RLock", "Semaphore", "Array", "Value", "dict", "list", "set", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.managers.SyncManager";
    rt.short_name = "SyncManager";
    rt.method_names = py_methods_673;
    static const char* py_bases_674[] = { "multiprocessing.managers.BaseManager", NULL };
    rt.embedded_types = py_bases_674;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SyncManager.Barrier";
    rf.short_name = "Barrier";
    rf.receiver_type = "multiprocessing.managers.SyncManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SyncManager.BoundedSemaphore";
    rf.short_name = "BoundedSemaphore";
    rf.receiver_type = "multiprocessing.managers.SyncManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SyncManager.Condition";
    rf.short_name = "Condition";
    rf.receiver_type = "multiprocessing.managers.SyncManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SyncManager.Event";
    rf.short_name = "Event";
    rf.receiver_type = "multiprocessing.managers.SyncManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SyncManager.Lock";
    rf.short_name = "Lock";
    rf.receiver_type = "multiprocessing.managers.SyncManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SyncManager.Namespace";
    rf.short_name = "Namespace";
    rf.receiver_type = "multiprocessing.managers.SyncManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SyncManager.Pool";
    rf.short_name = "Pool";
    rf.receiver_type = "multiprocessing.managers.SyncManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SyncManager.Queue";
    rf.short_name = "Queue";
    rf.receiver_type = "multiprocessing.managers.SyncManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SyncManager.JoinableQueue";
    rf.short_name = "JoinableQueue";
    rf.receiver_type = "multiprocessing.managers.SyncManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SyncManager.RLock";
    rf.short_name = "RLock";
    rf.receiver_type = "multiprocessing.managers.SyncManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SyncManager.Semaphore";
    rf.short_name = "Semaphore";
    rf.receiver_type = "multiprocessing.managers.SyncManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SyncManager.Array";
    rf.short_name = "Array";
    rf.receiver_type = "multiprocessing.managers.SyncManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SyncManager.Value";
    rf.short_name = "Value";
    rf.receiver_type = "multiprocessing.managers.SyncManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SyncManager.dict";
    rf.short_name = "dict";
    rf.receiver_type = "multiprocessing.managers.SyncManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SyncManager.list";
    rf.short_name = "list";
    rf.receiver_type = "multiprocessing.managers.SyncManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SyncManager.set";
    rf.short_name = "set";
    rf.receiver_type = "multiprocessing.managers.SyncManager";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.managers.RemoteError";
    rt.short_name = "RemoteError";
    static const char* py_bases_675[] = { "multiprocessing.managers.Exception", NULL };
    rt.embedded_types = py_bases_675;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_676[] = { "track_segment", "release_segment", "list_segments", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.managers.SharedMemoryServer";
    rt.short_name = "SharedMemoryServer";
    rt.method_names = py_methods_676;
    static const char* py_bases_677[] = { "multiprocessing.managers.Server", NULL };
    rt.embedded_types = py_bases_677;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SharedMemoryServer.track_segment";
    rf.short_name = "track_segment";
    rf.receiver_type = "multiprocessing.managers.SharedMemoryServer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SharedMemoryServer.release_segment";
    rf.short_name = "release_segment";
    rf.receiver_type = "multiprocessing.managers.SharedMemoryServer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SharedMemoryServer.list_segments";
    rf.short_name = "list_segments";
    rf.receiver_type = "multiprocessing.managers.SharedMemoryServer";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_678[] = { "get_server", "SharedMemory", "ShareableList", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.managers.SharedMemoryManager";
    rt.short_name = "SharedMemoryManager";
    rt.method_names = py_methods_678;
    static const char* py_bases_679[] = { "multiprocessing.managers.BaseManager", NULL };
    rt.embedded_types = py_bases_679;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SharedMemoryManager.get_server";
    rf.short_name = "get_server";
    rf.receiver_type = "multiprocessing.managers.SharedMemoryManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SharedMemoryManager.SharedMemory";
    rf.short_name = "SharedMemory";
    rf.receiver_type = "multiprocessing.managers.SharedMemoryManager";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.managers.SharedMemoryManager.ShareableList";
    rf.short_name = "ShareableList";
    rf.receiver_type = "multiprocessing.managers.SharedMemoryManager";
    cbm_registry_add_func(reg, rf);

    /* ===== module: multiprocessing.pool ===== */
    static const char* py_methods_680[] = { "__init__", "get", "wait", "ready", "successful", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.pool.ApplyResult";
    rt.short_name = "ApplyResult";
    rt.method_names = py_methods_680;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.ApplyResult.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.pool.ApplyResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.ApplyResult.get";
    rf.short_name = "get";
    rf.receiver_type = "multiprocessing.pool.ApplyResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.ApplyResult.wait";
    rf.short_name = "wait";
    rf.receiver_type = "multiprocessing.pool.ApplyResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.ApplyResult.ready";
    rf.short_name = "ready";
    rf.receiver_type = "multiprocessing.pool.ApplyResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.ApplyResult.successful";
    rf.short_name = "successful";
    rf.receiver_type = "multiprocessing.pool.ApplyResult";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_681[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.pool.MapResult";
    rt.short_name = "MapResult";
    rt.method_names = py_methods_681;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.MapResult.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.pool.MapResult";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_682[] = { "__init__", "next", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.pool.IMapIterator";
    rt.short_name = "IMapIterator";
    rt.method_names = py_methods_682;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.IMapIterator.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.pool.IMapIterator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.IMapIterator.next";
    rf.short_name = "next";
    rf.receiver_type = "multiprocessing.pool.IMapIterator";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.pool.IMapUnorderedIterator";
    rt.short_name = "IMapUnorderedIterator";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_683[] = { "__init__", "Process", "apply", "apply_async", "map", "map_async", "imap", "imap_unordered", "starmap", "starmap_async", "close", "terminate", "join", "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.pool.Pool";
    rt.short_name = "Pool";
    rt.method_names = py_methods_683;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.Pool.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.pool.Pool";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.Pool.Process";
    rf.short_name = "Process";
    rf.receiver_type = "multiprocessing.pool.Pool";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.Pool.apply";
    rf.short_name = "apply";
    rf.receiver_type = "multiprocessing.pool.Pool";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.Pool.apply_async";
    rf.short_name = "apply_async";
    rf.receiver_type = "multiprocessing.pool.Pool";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.Pool.map";
    rf.short_name = "map";
    rf.receiver_type = "multiprocessing.pool.Pool";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.Pool.map_async";
    rf.short_name = "map_async";
    rf.receiver_type = "multiprocessing.pool.Pool";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.Pool.imap";
    rf.short_name = "imap";
    rf.receiver_type = "multiprocessing.pool.Pool";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.Pool.imap_unordered";
    rf.short_name = "imap_unordered";
    rf.receiver_type = "multiprocessing.pool.Pool";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.Pool.starmap";
    rf.short_name = "starmap";
    rf.receiver_type = "multiprocessing.pool.Pool";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.Pool.starmap_async";
    rf.short_name = "starmap_async";
    rf.receiver_type = "multiprocessing.pool.Pool";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.Pool.close";
    rf.short_name = "close";
    rf.receiver_type = "multiprocessing.pool.Pool";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.Pool.terminate";
    rf.short_name = "terminate";
    rf.receiver_type = "multiprocessing.pool.Pool";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.Pool.join";
    rf.short_name = "join";
    rf.receiver_type = "multiprocessing.pool.Pool";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.Pool.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "multiprocessing.pool.Pool";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.Pool.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "multiprocessing.pool.Pool";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_684[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.pool.ThreadPool";
    rt.short_name = "ThreadPool";
    rt.method_names = py_methods_684;
    static const char* py_bases_685[] = { "multiprocessing.pool.Pool", NULL };
    rt.embedded_types = py_bases_685;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.pool.ThreadPool.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.pool.ThreadPool";
    cbm_registry_add_func(reg, rf);

    /* ===== module: multiprocessing.popen_fork ===== */
    static const char* py_methods_686[] = { "__init__", "duplicate_for_child", "poll", "wait", "interrupt", "terminate", "kill", "close", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.popen_fork.Popen";
    rt.short_name = "Popen";
    rt.method_names = py_methods_686;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.popen_fork.Popen.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.popen_fork.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.popen_fork.Popen.duplicate_for_child";
    rf.short_name = "duplicate_for_child";
    rf.receiver_type = "multiprocessing.popen_fork.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.popen_fork.Popen.poll";
    rf.short_name = "poll";
    rf.receiver_type = "multiprocessing.popen_fork.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.popen_fork.Popen.wait";
    rf.short_name = "wait";
    rf.receiver_type = "multiprocessing.popen_fork.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.popen_fork.Popen.interrupt";
    rf.short_name = "interrupt";
    rf.receiver_type = "multiprocessing.popen_fork.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.popen_fork.Popen.terminate";
    rf.short_name = "terminate";
    rf.receiver_type = "multiprocessing.popen_fork.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.popen_fork.Popen.kill";
    rf.short_name = "kill";
    rf.receiver_type = "multiprocessing.popen_fork.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.popen_fork.Popen.close";
    rf.short_name = "close";
    rf.receiver_type = "multiprocessing.popen_fork.Popen";
    cbm_registry_add_func(reg, rf);

    /* ===== module: multiprocessing.popen_forkserver ===== */
    static const char* py_methods_687[] = { "__init__", "detach", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.popen_forkserver._DupFd";
    rt.short_name = "_DupFd";
    rt.method_names = py_methods_687;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.popen_forkserver._DupFd.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.popen_forkserver._DupFd";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.popen_forkserver._DupFd.detach";
    rf.short_name = "detach";
    rf.receiver_type = "multiprocessing.popen_forkserver._DupFd";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.popen_forkserver.Popen";
    rt.short_name = "Popen";
    static const char* py_bases_688[] = { "popen_fork.Popen", NULL };
    rt.embedded_types = py_bases_688;
    cbm_registry_add_type(reg, rt);

    /* ===== module: multiprocessing.popen_spawn_posix ===== */
    static const char* py_methods_689[] = { "__init__", "detach", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.popen_spawn_posix._DupFd";
    rt.short_name = "_DupFd";
    rt.method_names = py_methods_689;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.popen_spawn_posix._DupFd.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.popen_spawn_posix._DupFd";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.popen_spawn_posix._DupFd.detach";
    rf.short_name = "detach";
    rf.receiver_type = "multiprocessing.popen_spawn_posix._DupFd";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.popen_spawn_posix.Popen";
    rt.short_name = "Popen";
    static const char* py_bases_690[] = { "popen_fork.Popen", NULL };
    rt.embedded_types = py_bases_690;
    cbm_registry_add_type(reg, rt);

    /* ===== module: multiprocessing.popen_spawn_win32 ===== */
    static const char* py_methods_691[] = { "__init__", "duplicate_for_child", "wait", "poll", "terminate", "close", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.popen_spawn_win32.Popen";
    rt.short_name = "Popen";
    rt.method_names = py_methods_691;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.popen_spawn_win32.Popen.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.popen_spawn_win32.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.popen_spawn_win32.Popen.duplicate_for_child";
    rf.short_name = "duplicate_for_child";
    rf.receiver_type = "multiprocessing.popen_spawn_win32.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.popen_spawn_win32.Popen.wait";
    rf.short_name = "wait";
    rf.receiver_type = "multiprocessing.popen_spawn_win32.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.popen_spawn_win32.Popen.poll";
    rf.short_name = "poll";
    rf.receiver_type = "multiprocessing.popen_spawn_win32.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.popen_spawn_win32.Popen.terminate";
    rf.short_name = "terminate";
    rf.receiver_type = "multiprocessing.popen_spawn_win32.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.popen_spawn_win32.Popen.close";
    rf.short_name = "close";
    rf.receiver_type = "multiprocessing.popen_spawn_win32.Popen";
    cbm_registry_add_func(reg, rf);

    /* ===== module: multiprocessing.process ===== */
    static const char* py_methods_692[] = { "__init__", "run", "start", "interrupt", "terminate", "kill", "close", "join", "is_alive", "exitcode", "ident", "pid", "sentinel", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.process.BaseProcess";
    rt.short_name = "BaseProcess";
    rt.method_names = py_methods_692;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.process.BaseProcess.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.process.BaseProcess";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.process.BaseProcess.run";
    rf.short_name = "run";
    rf.receiver_type = "multiprocessing.process.BaseProcess";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.process.BaseProcess.start";
    rf.short_name = "start";
    rf.receiver_type = "multiprocessing.process.BaseProcess";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.process.BaseProcess.interrupt";
    rf.short_name = "interrupt";
    rf.receiver_type = "multiprocessing.process.BaseProcess";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.process.BaseProcess.terminate";
    rf.short_name = "terminate";
    rf.receiver_type = "multiprocessing.process.BaseProcess";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.process.BaseProcess.kill";
    rf.short_name = "kill";
    rf.receiver_type = "multiprocessing.process.BaseProcess";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.process.BaseProcess.close";
    rf.short_name = "close";
    rf.receiver_type = "multiprocessing.process.BaseProcess";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.process.BaseProcess.join";
    rf.short_name = "join";
    rf.receiver_type = "multiprocessing.process.BaseProcess";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.process.BaseProcess.is_alive";
    rf.short_name = "is_alive";
    rf.receiver_type = "multiprocessing.process.BaseProcess";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.process.BaseProcess.exitcode";
    rf.short_name = "exitcode";
    rf.receiver_type = "multiprocessing.process.BaseProcess";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.process.BaseProcess.ident";
    rf.short_name = "ident";
    rf.receiver_type = "multiprocessing.process.BaseProcess";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.process.BaseProcess.pid";
    rf.short_name = "pid";
    rf.receiver_type = "multiprocessing.process.BaseProcess";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.process.BaseProcess.sentinel";
    rf.short_name = "sentinel";
    rf.receiver_type = "multiprocessing.process.BaseProcess";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.process.current_process";
    rf.short_name = "current_process";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.process.active_children";
    rf.short_name = "active_children";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.process.parent_process";
    rf.short_name = "parent_process";
    cbm_registry_add_func(reg, rf);

    /* ===== module: multiprocessing.queues ===== */
    static const char* py_methods_693[] = { "__init__", "put", "get", "qsize", "empty", "full", "get_nowait", "put_nowait", "close", "join_thread", "cancel_join_thread", "__class_getitem__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.queues.Queue";
    rt.short_name = "Queue";
    rt.method_names = py_methods_693;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.queues.Queue.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.queues.Queue.put";
    rf.short_name = "put";
    rf.receiver_type = "multiprocessing.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.queues.Queue.get";
    rf.short_name = "get";
    rf.receiver_type = "multiprocessing.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.queues.Queue.qsize";
    rf.short_name = "qsize";
    rf.receiver_type = "multiprocessing.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.queues.Queue.empty";
    rf.short_name = "empty";
    rf.receiver_type = "multiprocessing.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.queues.Queue.full";
    rf.short_name = "full";
    rf.receiver_type = "multiprocessing.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.queues.Queue.get_nowait";
    rf.short_name = "get_nowait";
    rf.receiver_type = "multiprocessing.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.queues.Queue.put_nowait";
    rf.short_name = "put_nowait";
    rf.receiver_type = "multiprocessing.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.queues.Queue.close";
    rf.short_name = "close";
    rf.receiver_type = "multiprocessing.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.queues.Queue.join_thread";
    rf.short_name = "join_thread";
    rf.receiver_type = "multiprocessing.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.queues.Queue.cancel_join_thread";
    rf.short_name = "cancel_join_thread";
    rf.receiver_type = "multiprocessing.queues.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.queues.Queue.__class_getitem__";
    rf.short_name = "__class_getitem__";
    rf.receiver_type = "multiprocessing.queues.Queue";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_694[] = { "task_done", "join", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.queues.JoinableQueue";
    rt.short_name = "JoinableQueue";
    rt.method_names = py_methods_694;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.queues.JoinableQueue.task_done";
    rf.short_name = "task_done";
    rf.receiver_type = "multiprocessing.queues.JoinableQueue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.queues.JoinableQueue.join";
    rf.short_name = "join";
    rf.receiver_type = "multiprocessing.queues.JoinableQueue";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_695[] = { "__init__", "close", "empty", "get", "put", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.queues.SimpleQueue";
    rt.short_name = "SimpleQueue";
    rt.method_names = py_methods_695;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.queues.SimpleQueue.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.queues.SimpleQueue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.queues.SimpleQueue.close";
    rf.short_name = "close";
    rf.receiver_type = "multiprocessing.queues.SimpleQueue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.queues.SimpleQueue.empty";
    rf.short_name = "empty";
    rf.receiver_type = "multiprocessing.queues.SimpleQueue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.queues.SimpleQueue.get";
    rf.short_name = "get";
    rf.receiver_type = "multiprocessing.queues.SimpleQueue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.queues.SimpleQueue.put";
    rf.short_name = "put";
    rf.receiver_type = "multiprocessing.queues.SimpleQueue";
    cbm_registry_add_func(reg, rf);

    /* ===== module: multiprocessing.reduction ===== */
    static const char* py_methods_696[] = { "__init__", "register", "dumps", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.reduction.ForkingPickler";
    rt.short_name = "ForkingPickler";
    rt.method_names = py_methods_696;
    static const char* py_bases_697[] = { "pickle.Pickler", NULL };
    rt.embedded_types = py_bases_697;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.reduction.ForkingPickler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.reduction.ForkingPickler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.reduction.ForkingPickler.register";
    rf.short_name = "register";
    rf.receiver_type = "multiprocessing.reduction.ForkingPickler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.reduction.ForkingPickler.dumps";
    rf.short_name = "dumps";
    rf.receiver_type = "multiprocessing.reduction.ForkingPickler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_698[] = { "__init__", "detach", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.reduction.DupHandle";
    rt.short_name = "DupHandle";
    rt.method_names = py_methods_698;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.reduction.DupHandle.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.reduction.DupHandle";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.reduction.DupHandle.detach";
    rf.short_name = "detach";
    rf.receiver_type = "multiprocessing.reduction.DupHandle";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_699[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.reduction.AbstractReducer";
    rt.short_name = "AbstractReducer";
    rt.method_names = py_methods_699;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.reduction.AbstractReducer.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.reduction.AbstractReducer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.reduction.dump";
    rf.short_name = "dump";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.reduction.duplicate";
    rf.short_name = "duplicate";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.reduction.steal_handle";
    rf.short_name = "steal_handle";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.reduction.send_handle";
    rf.short_name = "send_handle";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.reduction.recv_handle";
    rf.short_name = "recv_handle";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.reduction.recvfds";
    rf.short_name = "recvfds";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.reduction.sendfds";
    rf.short_name = "sendfds";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.reduction.DupFd";
    rf.short_name = "DupFd";
    cbm_registry_add_func(reg, rf);

    /* ===== module: multiprocessing.resource_sharer ===== */
    static const char* py_methods_700[] = { "__init__", "detach", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.resource_sharer.DupSocket";
    rt.short_name = "DupSocket";
    rt.method_names = py_methods_700;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.resource_sharer.DupSocket.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.resource_sharer.DupSocket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.resource_sharer.DupSocket.detach";
    rf.short_name = "detach";
    rf.receiver_type = "multiprocessing.resource_sharer.DupSocket";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_701[] = { "__init__", "detach", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.resource_sharer.DupFd";
    rt.short_name = "DupFd";
    rt.method_names = py_methods_701;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.resource_sharer.DupFd.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.resource_sharer.DupFd";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.resource_sharer.DupFd.detach";
    rf.short_name = "detach";
    rf.receiver_type = "multiprocessing.resource_sharer.DupFd";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.resource_sharer.stop";
    rf.short_name = "stop";
    cbm_registry_add_func(reg, rf);

    /* ===== module: multiprocessing.resource_tracker ===== */
    static const char* py_methods_702[] = { "getfd", "ensure_running", "register", "unregister", "__del__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.resource_tracker.ResourceTracker";
    rt.short_name = "ResourceTracker";
    rt.method_names = py_methods_702;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.resource_tracker.ResourceTracker.getfd";
    rf.short_name = "getfd";
    rf.receiver_type = "multiprocessing.resource_tracker.ResourceTracker";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.resource_tracker.ResourceTracker.ensure_running";
    rf.short_name = "ensure_running";
    rf.receiver_type = "multiprocessing.resource_tracker.ResourceTracker";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.resource_tracker.ResourceTracker.register";
    rf.short_name = "register";
    rf.receiver_type = "multiprocessing.resource_tracker.ResourceTracker";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.resource_tracker.ResourceTracker.unregister";
    rf.short_name = "unregister";
    rf.receiver_type = "multiprocessing.resource_tracker.ResourceTracker";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.resource_tracker.ResourceTracker.__del__";
    rf.short_name = "__del__";
    rf.receiver_type = "multiprocessing.resource_tracker.ResourceTracker";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.resource_tracker.main";
    rf.short_name = "main";
    cbm_registry_add_func(reg, rf);

    /* ===== module: multiprocessing.shared_memory ===== */
    static const char* py_methods_703[] = { "__init__", "buf", "name", "size", "close", "unlink", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.shared_memory.SharedMemory";
    rt.short_name = "SharedMemory";
    rt.method_names = py_methods_703;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.shared_memory.SharedMemory.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.shared_memory.SharedMemory";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.shared_memory.SharedMemory.buf";
    rf.short_name = "buf";
    rf.receiver_type = "multiprocessing.shared_memory.SharedMemory";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.shared_memory.SharedMemory.name";
    rf.short_name = "name";
    rf.receiver_type = "multiprocessing.shared_memory.SharedMemory";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.shared_memory.SharedMemory.size";
    rf.short_name = "size";
    rf.receiver_type = "multiprocessing.shared_memory.SharedMemory";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.shared_memory.SharedMemory.close";
    rf.short_name = "close";
    rf.receiver_type = "multiprocessing.shared_memory.SharedMemory";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.shared_memory.SharedMemory.unlink";
    rf.short_name = "unlink";
    rf.receiver_type = "multiprocessing.shared_memory.SharedMemory";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_704[] = { "__init__", "format", "count", "index", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.shared_memory.ShareableList";
    rt.short_name = "ShareableList";
    rt.method_names = py_methods_704;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.shared_memory.ShareableList.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.shared_memory.ShareableList";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.shared_memory.ShareableList.format";
    rf.short_name = "format";
    rf.receiver_type = "multiprocessing.shared_memory.ShareableList";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.shared_memory.ShareableList.count";
    rf.short_name = "count";
    rf.receiver_type = "multiprocessing.shared_memory.ShareableList";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.shared_memory.ShareableList.index";
    rf.short_name = "index";
    rf.receiver_type = "multiprocessing.shared_memory.ShareableList";
    cbm_registry_add_func(reg, rf);

    /* ===== module: multiprocessing.sharedctypes ===== */
    static const char* py_methods_705[] = { "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.sharedctypes._AcquireFunc";
    rt.short_name = "_AcquireFunc";
    rt.method_names = py_methods_705;
    static const char* py_bases_706[] = { "multiprocessing.sharedctypes.Protocol", NULL };
    rt.embedded_types = py_bases_706;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.sharedctypes._AcquireFunc.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "multiprocessing.sharedctypes._AcquireFunc";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_707[] = { "__init__", "get_obj", "get_lock", "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.sharedctypes.SynchronizedBase";
    rt.short_name = "SynchronizedBase";
    rt.method_names = py_methods_707;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.sharedctypes.SynchronizedBase.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.sharedctypes.SynchronizedBase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.sharedctypes.SynchronizedBase.get_obj";
    rf.short_name = "get_obj";
    rf.receiver_type = "multiprocessing.sharedctypes.SynchronizedBase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.sharedctypes.SynchronizedBase.get_lock";
    rf.short_name = "get_lock";
    rf.receiver_type = "multiprocessing.sharedctypes.SynchronizedBase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.sharedctypes.SynchronizedBase.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "multiprocessing.sharedctypes.SynchronizedBase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.sharedctypes.SynchronizedBase.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "multiprocessing.sharedctypes.SynchronizedBase";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.sharedctypes.Synchronized";
    rt.short_name = "Synchronized";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.sharedctypes.SynchronizedArray";
    rt.short_name = "SynchronizedArray";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.sharedctypes.SynchronizedString";
    rt.short_name = "SynchronizedString";
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.sharedctypes.RawValue";
    rf.short_name = "RawValue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.sharedctypes.RawArray";
    rf.short_name = "RawArray";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.sharedctypes.Value";
    rf.short_name = "Value";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.sharedctypes.Array";
    rf.short_name = "Array";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.sharedctypes.copy";
    rf.short_name = "copy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.sharedctypes.synchronized";
    rf.short_name = "synchronized";
    cbm_registry_add_func(reg, rf);

    /* ===== module: multiprocessing.spawn ===== */
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.spawn.set_executable";
    rf.short_name = "set_executable";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.spawn.get_executable";
    rf.short_name = "get_executable";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.spawn.is_forking";
    rf.short_name = "is_forking";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.spawn.freeze_support";
    rf.short_name = "freeze_support";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.spawn.get_command_line";
    rf.short_name = "get_command_line";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.spawn.spawn_main";
    rf.short_name = "spawn_main";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.spawn.get_preparation_data";
    rf.short_name = "get_preparation_data";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.spawn.prepare";
    rf.short_name = "prepare";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.spawn.import_main_path";
    rf.short_name = "import_main_path";
    cbm_registry_add_func(reg, rf);

    /* ===== module: multiprocessing.synchronize ===== */
    static const char* py_methods_708[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.synchronize.Barrier";
    rt.short_name = "Barrier";
    rt.method_names = py_methods_708;
    static const char* py_bases_709[] = { "threading.Barrier", NULL };
    rt.embedded_types = py_bases_709;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.Barrier.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.synchronize.Barrier";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_710[] = { "__init__", "notify", "notify_all", "wait", "wait_for", "__enter__", "__exit__", "acquire", "release", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.synchronize.Condition";
    rt.short_name = "Condition";
    rt.method_names = py_methods_710;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.Condition.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.synchronize.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.Condition.notify";
    rf.short_name = "notify";
    rf.receiver_type = "multiprocessing.synchronize.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.Condition.notify_all";
    rf.short_name = "notify_all";
    rf.receiver_type = "multiprocessing.synchronize.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.Condition.wait";
    rf.short_name = "wait";
    rf.receiver_type = "multiprocessing.synchronize.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.Condition.wait_for";
    rf.short_name = "wait_for";
    rf.receiver_type = "multiprocessing.synchronize.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.Condition.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "multiprocessing.synchronize.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.Condition.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "multiprocessing.synchronize.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.Condition.acquire";
    rf.short_name = "acquire";
    rf.receiver_type = "multiprocessing.synchronize.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.Condition.release";
    rf.short_name = "release";
    rf.receiver_type = "multiprocessing.synchronize.Condition";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_711[] = { "__init__", "is_set", "set", "clear", "wait", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.synchronize.Event";
    rt.short_name = "Event";
    rt.method_names = py_methods_711;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.Event.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.synchronize.Event";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.Event.is_set";
    rf.short_name = "is_set";
    rf.receiver_type = "multiprocessing.synchronize.Event";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.Event.set";
    rf.short_name = "set";
    rf.receiver_type = "multiprocessing.synchronize.Event";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.Event.clear";
    rf.short_name = "clear";
    rf.receiver_type = "multiprocessing.synchronize.Event";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.Event.wait";
    rf.short_name = "wait";
    rf.receiver_type = "multiprocessing.synchronize.Event";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_712[] = { "__init__", "__enter__", "__exit__", "acquire", "release", "locked", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.synchronize.SemLock";
    rt.short_name = "SemLock";
    rt.method_names = py_methods_712;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.SemLock.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.synchronize.SemLock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.SemLock.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "multiprocessing.synchronize.SemLock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.SemLock.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "multiprocessing.synchronize.SemLock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.SemLock.acquire";
    rf.short_name = "acquire";
    rf.receiver_type = "multiprocessing.synchronize.SemLock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.SemLock.release";
    rf.short_name = "release";
    rf.receiver_type = "multiprocessing.synchronize.SemLock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.SemLock.locked";
    rf.short_name = "locked";
    rf.receiver_type = "multiprocessing.synchronize.SemLock";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_713[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.synchronize.Lock";
    rt.short_name = "Lock";
    rt.method_names = py_methods_713;
    static const char* py_bases_714[] = { "multiprocessing.synchronize.SemLock", NULL };
    rt.embedded_types = py_bases_714;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.Lock.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.synchronize.Lock";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_715[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.synchronize.RLock";
    rt.short_name = "RLock";
    rt.method_names = py_methods_715;
    static const char* py_bases_716[] = { "multiprocessing.synchronize.SemLock", NULL };
    rt.embedded_types = py_bases_716;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.RLock.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.synchronize.RLock";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_717[] = { "__init__", "get_value", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.synchronize.Semaphore";
    rt.short_name = "Semaphore";
    rt.method_names = py_methods_717;
    static const char* py_bases_718[] = { "multiprocessing.synchronize.SemLock", NULL };
    rt.embedded_types = py_bases_718;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.Semaphore.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.synchronize.Semaphore";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.Semaphore.get_value";
    rf.short_name = "get_value";
    rf.receiver_type = "multiprocessing.synchronize.Semaphore";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_719[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.synchronize.BoundedSemaphore";
    rt.short_name = "BoundedSemaphore";
    rt.method_names = py_methods_719;
    static const char* py_bases_720[] = { "multiprocessing.synchronize.Semaphore", NULL };
    rt.embedded_types = py_bases_720;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.synchronize.BoundedSemaphore.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.synchronize.BoundedSemaphore";
    cbm_registry_add_func(reg, rf);

    /* ===== module: multiprocessing.util ===== */
    static const char* py_methods_721[] = { "__init__", "__call__", "cancel", "still_active", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.util.Finalize";
    rt.short_name = "Finalize";
    rt.method_names = py_methods_721;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.util.Finalize.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "multiprocessing.util.Finalize";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.util.Finalize.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "multiprocessing.util.Finalize";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.util.Finalize.cancel";
    rf.short_name = "cancel";
    rf.receiver_type = "multiprocessing.util.Finalize";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.util.Finalize.still_active";
    rf.short_name = "still_active";
    rf.receiver_type = "multiprocessing.util.Finalize";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_722[] = { "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.util.ForkAwareThreadLock";
    rt.short_name = "ForkAwareThreadLock";
    rt.method_names = py_methods_722;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.util.ForkAwareThreadLock.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "multiprocessing.util.ForkAwareThreadLock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.util.ForkAwareThreadLock.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "multiprocessing.util.ForkAwareThreadLock";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "multiprocessing.util.ForkAwareLocal";
    rt.short_name = "ForkAwareLocal";
    static const char* py_bases_723[] = { "threading.local", NULL };
    rt.embedded_types = py_bases_723;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.util.sub_debug";
    rf.short_name = "sub_debug";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.util.debug";
    rf.short_name = "debug";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.util.info";
    rf.short_name = "info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.util.warn";
    rf.short_name = "warn";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.util.sub_warning";
    rf.short_name = "sub_warning";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.util.get_logger";
    rf.short_name = "get_logger";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.util.log_to_stderr";
    rf.short_name = "log_to_stderr";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.util.is_abstract_socket_namespace";
    rf.short_name = "is_abstract_socket_namespace";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.util.get_temp_dir";
    rf.short_name = "get_temp_dir";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.util.register_after_fork";
    rf.short_name = "register_after_fork";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.util.is_exiting";
    rf.short_name = "is_exiting";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.util.close_all_fds_except";
    rf.short_name = "close_all_fds_except";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "multiprocessing.util.spawnv_passfds";
    rf.short_name = "spawnv_passfds";
    cbm_registry_add_func(reg, rf);

    /* ===== module: ntpath ===== */
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "ntpath.join";
    rf.short_name = "join";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "ntpath.realpath";
    rf.short_name = "realpath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "ntpath.isreserved";
    rf.short_name = "isreserved";
    cbm_registry_add_func(reg, rf);

    /* ===== module: os ===== */
    static const char* py_methods_724[] = { "__init__", "get", "pop", "setdefault", "copy", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os._Environ";
    rt.short_name = "_Environ";
    rt.method_names = py_methods_724;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._Environ.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "os._Environ";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._Environ.get";
    rf.short_name = "get";
    rf.receiver_type = "os._Environ";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._Environ.pop";
    rf.short_name = "pop";
    rf.receiver_type = "os._Environ";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._Environ.setdefault";
    rf.short_name = "setdefault";
    rf.receiver_type = "os._Environ";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._Environ.copy";
    rf.short_name = "copy";
    rf.receiver_type = "os._Environ";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_725[] = { "st_mode", "st_ino", "st_dev", "st_nlink", "st_uid", "st_gid", "st_size", "st_atime", "st_mtime", "st_ctime", "st_atime_ns", "st_mtime_ns", "st_ctime_ns", "st_file_attributes", "st_reparse_tag", "st_blocks", "st_blksize", "st_rdev", "st_flags", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.stat_result";
    rt.short_name = "stat_result";
    rt.method_names = py_methods_725;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.stat_result.st_mode";
    rf.short_name = "st_mode";
    rf.receiver_type = "os.stat_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.stat_result.st_ino";
    rf.short_name = "st_ino";
    rf.receiver_type = "os.stat_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.stat_result.st_dev";
    rf.short_name = "st_dev";
    rf.receiver_type = "os.stat_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.stat_result.st_nlink";
    rf.short_name = "st_nlink";
    rf.receiver_type = "os.stat_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.stat_result.st_uid";
    rf.short_name = "st_uid";
    rf.receiver_type = "os.stat_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.stat_result.st_gid";
    rf.short_name = "st_gid";
    rf.receiver_type = "os.stat_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.stat_result.st_size";
    rf.short_name = "st_size";
    rf.receiver_type = "os.stat_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.stat_result.st_atime";
    rf.short_name = "st_atime";
    rf.receiver_type = "os.stat_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.stat_result.st_mtime";
    rf.short_name = "st_mtime";
    rf.receiver_type = "os.stat_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.stat_result.st_ctime";
    rf.short_name = "st_ctime";
    rf.receiver_type = "os.stat_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.stat_result.st_atime_ns";
    rf.short_name = "st_atime_ns";
    rf.receiver_type = "os.stat_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.stat_result.st_mtime_ns";
    rf.short_name = "st_mtime_ns";
    rf.receiver_type = "os.stat_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.stat_result.st_ctime_ns";
    rf.short_name = "st_ctime_ns";
    rf.receiver_type = "os.stat_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.stat_result.st_file_attributes";
    rf.short_name = "st_file_attributes";
    rf.receiver_type = "os.stat_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.stat_result.st_reparse_tag";
    rf.short_name = "st_reparse_tag";
    rf.receiver_type = "os.stat_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.stat_result.st_blocks";
    rf.short_name = "st_blocks";
    rf.receiver_type = "os.stat_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.stat_result.st_blksize";
    rf.short_name = "st_blksize";
    rf.receiver_type = "os.stat_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.stat_result.st_rdev";
    rf.short_name = "st_rdev";
    rf.receiver_type = "os.stat_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.stat_result.st_flags";
    rf.short_name = "st_flags";
    rf.receiver_type = "os.stat_result";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.PathLike";
    rt.short_name = "PathLike";
    static const char* py_bases_726[] = { "os.ABC", NULL };
    rt.embedded_types = py_bases_726;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_727[] = { "name", "path", "inode", "is_dir", "is_file", "is_symlink", "stat", "is_junction", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.DirEntry";
    rt.short_name = "DirEntry";
    rt.method_names = py_methods_727;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.DirEntry.name";
    rf.short_name = "name";
    rf.receiver_type = "os.DirEntry";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.DirEntry.path";
    rf.short_name = "path";
    rf.receiver_type = "os.DirEntry";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.DirEntry.inode";
    rf.short_name = "inode";
    rf.receiver_type = "os.DirEntry";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.DirEntry.is_dir";
    rf.short_name = "is_dir";
    rf.receiver_type = "os.DirEntry";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.DirEntry.is_file";
    rf.short_name = "is_file";
    rf.receiver_type = "os.DirEntry";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.DirEntry.is_symlink";
    rf.short_name = "is_symlink";
    rf.receiver_type = "os.DirEntry";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.DirEntry.stat";
    rf.short_name = "stat";
    rf.receiver_type = "os.DirEntry";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.DirEntry.is_junction";
    rf.short_name = "is_junction";
    rf.receiver_type = "os.DirEntry";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_728[] = { "f_bsize", "f_frsize", "f_blocks", "f_bfree", "f_bavail", "f_files", "f_ffree", "f_favail", "f_flag", "f_namemax", "f_fsid", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.statvfs_result";
    rt.short_name = "statvfs_result";
    rt.method_names = py_methods_728;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.statvfs_result.f_bsize";
    rf.short_name = "f_bsize";
    rf.receiver_type = "os.statvfs_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.statvfs_result.f_frsize";
    rf.short_name = "f_frsize";
    rf.receiver_type = "os.statvfs_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.statvfs_result.f_blocks";
    rf.short_name = "f_blocks";
    rf.receiver_type = "os.statvfs_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.statvfs_result.f_bfree";
    rf.short_name = "f_bfree";
    rf.receiver_type = "os.statvfs_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.statvfs_result.f_bavail";
    rf.short_name = "f_bavail";
    rf.receiver_type = "os.statvfs_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.statvfs_result.f_files";
    rf.short_name = "f_files";
    rf.receiver_type = "os.statvfs_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.statvfs_result.f_ffree";
    rf.short_name = "f_ffree";
    rf.receiver_type = "os.statvfs_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.statvfs_result.f_favail";
    rf.short_name = "f_favail";
    rf.receiver_type = "os.statvfs_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.statvfs_result.f_flag";
    rf.short_name = "f_flag";
    rf.receiver_type = "os.statvfs_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.statvfs_result.f_namemax";
    rf.short_name = "f_namemax";
    rf.receiver_type = "os.statvfs_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.statvfs_result.f_fsid";
    rf.short_name = "f_fsid";
    rf.receiver_type = "os.statvfs_result";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_729[] = { "sysname", "nodename", "release", "version", "machine", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.uname_result";
    rt.short_name = "uname_result";
    rt.method_names = py_methods_729;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.uname_result.sysname";
    rf.short_name = "sysname";
    rf.receiver_type = "os.uname_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.uname_result.nodename";
    rf.short_name = "nodename";
    rf.receiver_type = "os.uname_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.uname_result.release";
    rf.short_name = "release";
    rf.receiver_type = "os.uname_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.uname_result.version";
    rf.short_name = "version";
    rf.receiver_type = "os.uname_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.uname_result.machine";
    rf.short_name = "machine";
    rf.receiver_type = "os.uname_result";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_730[] = { "columns", "lines", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.terminal_size";
    rt.short_name = "terminal_size";
    rt.method_names = py_methods_730;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.terminal_size.columns";
    rf.short_name = "columns";
    rf.receiver_type = "os.terminal_size";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.terminal_size.lines";
    rf.short_name = "lines";
    rf.receiver_type = "os.terminal_size";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_731[] = { "__enter__", "__exit__", "close", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os._ScandirIterator";
    rt.short_name = "_ScandirIterator";
    rt.method_names = py_methods_731;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._ScandirIterator.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "os._ScandirIterator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._ScandirIterator.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "os._ScandirIterator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._ScandirIterator.close";
    rf.short_name = "close";
    rf.receiver_type = "os._ScandirIterator";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_732[] = { "__init__", "close", "__enter__", "__exit__", "read", "readable", "readline", "readlines", "writable", "write", "writelines", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os._wrap_close";
    rt.short_name = "_wrap_close";
    rt.method_names = py_methods_732;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._wrap_close.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "os._wrap_close";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._wrap_close.close";
    rf.short_name = "close";
    rf.receiver_type = "os._wrap_close";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._wrap_close.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "os._wrap_close";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._wrap_close.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "os._wrap_close";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._wrap_close.read";
    rf.short_name = "read";
    rf.receiver_type = "os._wrap_close";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._wrap_close.readable";
    rf.short_name = "readable";
    rf.receiver_type = "os._wrap_close";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._wrap_close.readline";
    rf.short_name = "readline";
    rf.receiver_type = "os._wrap_close";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._wrap_close.readlines";
    rf.short_name = "readlines";
    rf.receiver_type = "os._wrap_close";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._wrap_close.writable";
    rf.short_name = "writable";
    rf.receiver_type = "os._wrap_close";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._wrap_close.write";
    rf.short_name = "write";
    rf.receiver_type = "os._wrap_close";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._wrap_close.writelines";
    rf.short_name = "writelines";
    rf.receiver_type = "os._wrap_close";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_733[] = { "user", "system", "children_user", "children_system", "elapsed", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.times_result";
    rt.short_name = "times_result";
    rt.method_names = py_methods_733;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.times_result.user";
    rf.short_name = "user";
    rf.receiver_type = "os.times_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.times_result.system";
    rf.short_name = "system";
    rf.receiver_type = "os.times_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.times_result.children_user";
    rf.short_name = "children_user";
    rf.receiver_type = "os.times_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.times_result.children_system";
    rf.short_name = "children_system";
    rf.receiver_type = "os.times_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.times_result.elapsed";
    rf.short_name = "elapsed";
    rf.receiver_type = "os.times_result";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_734[] = { "si_pid", "si_uid", "si_signo", "si_status", "si_code", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.waitid_result";
    rt.short_name = "waitid_result";
    rt.method_names = py_methods_734;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.waitid_result.si_pid";
    rf.short_name = "si_pid";
    rf.receiver_type = "os.waitid_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.waitid_result.si_uid";
    rf.short_name = "si_uid";
    rf.receiver_type = "os.waitid_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.waitid_result.si_signo";
    rf.short_name = "si_signo";
    rf.receiver_type = "os.waitid_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.waitid_result.si_status";
    rf.short_name = "si_status";
    rf.receiver_type = "os.waitid_result";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.waitid_result.si_code";
    rf.short_name = "si_code";
    rf.receiver_type = "os.waitid_result";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_735[] = { "sched_priority", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.sched_param";
    rt.short_name = "sched_param";
    rt.method_names = py_methods_735;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.sched_param.sched_priority";
    rf.short_name = "sched_priority";
    rf.receiver_type = "os.sched_param";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_736[] = { "__init__", "close", "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os._AddedDllDirectory";
    rt.short_name = "_AddedDllDirectory";
    rt.method_names = py_methods_736;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._AddedDllDirectory.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "os._AddedDllDirectory";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._AddedDllDirectory.close";
    rf.short_name = "close";
    rf.receiver_type = "os._AddedDllDirectory";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._AddedDllDirectory.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "os._AddedDllDirectory";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os._AddedDllDirectory.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "os._AddedDllDirectory";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.reload_environ";
    rf.short_name = "reload_environ";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.listdir";
    rf.short_name = "listdir";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fsencode";
    rf.short_name = "fsencode";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fsdecode";
    rf.short_name = "fsdecode";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fspath";
    rf.short_name = "fspath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.get_exec_path";
    rf.short_name = "get_exec_path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getlogin";
    rf.short_name = "getlogin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getpid";
    rf.short_name = "getpid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getppid";
    rf.short_name = "getppid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.strerror";
    rf.short_name = "strerror";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.umask";
    rf.short_name = "umask";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.ctermid";
    rf.short_name = "ctermid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getegid";
    rf.short_name = "getegid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.geteuid";
    rf.short_name = "geteuid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getgid";
    rf.short_name = "getgid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getgrouplist";
    rf.short_name = "getgrouplist";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getgroups";
    rf.short_name = "getgroups";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.initgroups";
    rf.short_name = "initgroups";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getpgid";
    rf.short_name = "getpgid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getpgrp";
    rf.short_name = "getpgrp";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getpriority";
    rf.short_name = "getpriority";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.setpriority";
    rf.short_name = "setpriority";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getresuid";
    rf.short_name = "getresuid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getresgid";
    rf.short_name = "getresgid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getuid";
    rf.short_name = "getuid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.setegid";
    rf.short_name = "setegid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.seteuid";
    rf.short_name = "seteuid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.setgid";
    rf.short_name = "setgid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.setgroups";
    rf.short_name = "setgroups";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.setpgrp";
    rf.short_name = "setpgrp";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.setpgid";
    rf.short_name = "setpgid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.setregid";
    rf.short_name = "setregid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.setresgid";
    rf.short_name = "setresgid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.setresuid";
    rf.short_name = "setresuid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.setreuid";
    rf.short_name = "setreuid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getsid";
    rf.short_name = "getsid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.setsid";
    rf.short_name = "setsid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.setuid";
    rf.short_name = "setuid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.uname";
    rf.short_name = "uname";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getenv";
    rf.short_name = "getenv";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getenvb";
    rf.short_name = "getenvb";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.putenv";
    rf.short_name = "putenv";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.unsetenv";
    rf.short_name = "unsetenv";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fdopen";
    rf.short_name = "fdopen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.close";
    rf.short_name = "close";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.closerange";
    rf.short_name = "closerange";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.device_encoding";
    rf.short_name = "device_encoding";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.dup";
    rf.short_name = "dup";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.dup2";
    rf.short_name = "dup2";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fstat";
    rf.short_name = "fstat";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.ftruncate";
    rf.short_name = "ftruncate";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fsync";
    rf.short_name = "fsync";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.isatty";
    rf.short_name = "isatty";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.login_tty";
    rf.short_name = "login_tty";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.lseek";
    rf.short_name = "lseek";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.open";
    rf.short_name = "open";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.pipe";
    rf.short_name = "pipe";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.read";
    rf.short_name = "read";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.get_blocking";
    rf.short_name = "get_blocking";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.set_blocking";
    rf.short_name = "set_blocking";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fchown";
    rf.short_name = "fchown";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fpathconf";
    rf.short_name = "fpathconf";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fstatvfs";
    rf.short_name = "fstatvfs";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.lockf";
    rf.short_name = "lockf";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.openpty";
    rf.short_name = "openpty";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fdatasync";
    rf.short_name = "fdatasync";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.pipe2";
    rf.short_name = "pipe2";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.posix_fallocate";
    rf.short_name = "posix_fallocate";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.posix_fadvise";
    rf.short_name = "posix_fadvise";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.pread";
    rf.short_name = "pread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.pwrite";
    rf.short_name = "pwrite";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.preadv";
    rf.short_name = "preadv";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.pwritev";
    rf.short_name = "pwritev";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.sendfile";
    rf.short_name = "sendfile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.readv";
    rf.short_name = "readv";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.writev";
    rf.short_name = "writev";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.readinto";
    rf.short_name = "readinto";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.get_terminal_size";
    rf.short_name = "get_terminal_size";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.get_inheritable";
    rf.short_name = "get_inheritable";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.set_inheritable";
    rf.short_name = "set_inheritable";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.get_handle_inheritable";
    rf.short_name = "get_handle_inheritable";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.set_handle_inheritable";
    rf.short_name = "set_handle_inheritable";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.tcgetpgrp";
    rf.short_name = "tcgetpgrp";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.tcsetpgrp";
    rf.short_name = "tcsetpgrp";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.ttyname";
    rf.short_name = "ttyname";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.write";
    rf.short_name = "write";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.access";
    rf.short_name = "access";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.chdir";
    rf.short_name = "chdir";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fchdir";
    rf.short_name = "fchdir";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getcwd";
    rf.short_name = "getcwd";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getcwdb";
    rf.short_name = "getcwdb";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.chmod";
    rf.short_name = "chmod";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.chflags";
    rf.short_name = "chflags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.lchflags";
    rf.short_name = "lchflags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.chroot";
    rf.short_name = "chroot";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.chown";
    rf.short_name = "chown";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.lchown";
    rf.short_name = "lchown";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.link";
    rf.short_name = "link";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.lstat";
    rf.short_name = "lstat";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.mkdir";
    rf.short_name = "mkdir";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.mkfifo";
    rf.short_name = "mkfifo";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.makedirs";
    rf.short_name = "makedirs";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.mknod";
    rf.short_name = "mknod";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.major";
    rf.short_name = "major";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.minor";
    rf.short_name = "minor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.makedev";
    rf.short_name = "makedev";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.pathconf";
    rf.short_name = "pathconf";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.readlink";
    rf.short_name = "readlink";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.remove";
    rf.short_name = "remove";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.removedirs";
    rf.short_name = "removedirs";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.rename";
    rf.short_name = "rename";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.renames";
    rf.short_name = "renames";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.replace";
    rf.short_name = "replace";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.rmdir";
    rf.short_name = "rmdir";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.scandir";
    rf.short_name = "scandir";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.stat";
    rf.short_name = "stat";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.statvfs";
    rf.short_name = "statvfs";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.symlink";
    rf.short_name = "symlink";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.sync";
    rf.short_name = "sync";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.truncate";
    rf.short_name = "truncate";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.unlink";
    rf.short_name = "unlink";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.utime";
    rf.short_name = "utime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.walk";
    rf.short_name = "walk";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fwalk";
    rf.short_name = "fwalk";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getxattr";
    rf.short_name = "getxattr";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.listxattr";
    rf.short_name = "listxattr";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.removexattr";
    rf.short_name = "removexattr";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.setxattr";
    rf.short_name = "setxattr";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.abort";
    rf.short_name = "abort";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.execl";
    rf.short_name = "execl";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.execlp";
    rf.short_name = "execlp";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.execle";
    rf.short_name = "execle";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.execlpe";
    rf.short_name = "execlpe";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.execv";
    rf.short_name = "execv";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.execve";
    rf.short_name = "execve";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.execvp";
    rf.short_name = "execvp";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.execvpe";
    rf.short_name = "execvpe";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.kill";
    rf.short_name = "kill";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fork";
    rf.short_name = "fork";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.forkpty";
    rf.short_name = "forkpty";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.killpg";
    rf.short_name = "killpg";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.nice";
    rf.short_name = "nice";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.plock";
    rf.short_name = "plock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.popen";
    rf.short_name = "popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.spawnl";
    rf.short_name = "spawnl";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.spawnle";
    rf.short_name = "spawnle";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.spawnv";
    rf.short_name = "spawnv";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.spawnve";
    rf.short_name = "spawnve";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.system";
    rf.short_name = "system";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.times";
    rf.short_name = "times";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.waitpid";
    rf.short_name = "waitpid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.startfile";
    rf.short_name = "startfile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.spawnlp";
    rf.short_name = "spawnlp";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.spawnlpe";
    rf.short_name = "spawnlpe";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.spawnvp";
    rf.short_name = "spawnvp";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.spawnvpe";
    rf.short_name = "spawnvpe";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.wait";
    rf.short_name = "wait";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.waitid";
    rf.short_name = "waitid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.wait3";
    rf.short_name = "wait3";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.wait4";
    rf.short_name = "wait4";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.WCOREDUMP";
    rf.short_name = "WCOREDUMP";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.WIFCONTINUED";
    rf.short_name = "WIFCONTINUED";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.WIFSTOPPED";
    rf.short_name = "WIFSTOPPED";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.WIFSIGNALED";
    rf.short_name = "WIFSIGNALED";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.WIFEXITED";
    rf.short_name = "WIFEXITED";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.WEXITSTATUS";
    rf.short_name = "WEXITSTATUS";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.WSTOPSIG";
    rf.short_name = "WSTOPSIG";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.WTERMSIG";
    rf.short_name = "WTERMSIG";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.posix_spawn";
    rf.short_name = "posix_spawn";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.posix_spawnp";
    rf.short_name = "posix_spawnp";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.sched_get_priority_min";
    rf.short_name = "sched_get_priority_min";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.sched_get_priority_max";
    rf.short_name = "sched_get_priority_max";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.sched_yield";
    rf.short_name = "sched_yield";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.sched_setscheduler";
    rf.short_name = "sched_setscheduler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.sched_getscheduler";
    rf.short_name = "sched_getscheduler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.sched_rr_get_interval";
    rf.short_name = "sched_rr_get_interval";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.sched_setparam";
    rf.short_name = "sched_setparam";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.sched_getparam";
    rf.short_name = "sched_getparam";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.sched_setaffinity";
    rf.short_name = "sched_setaffinity";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.sched_getaffinity";
    rf.short_name = "sched_getaffinity";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.cpu_count";
    rf.short_name = "cpu_count";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.process_cpu_count";
    rf.short_name = "process_cpu_count";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.confstr";
    rf.short_name = "confstr";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getloadavg";
    rf.short_name = "getloadavg";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.sysconf";
    rf.short_name = "sysconf";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.getrandom";
    rf.short_name = "getrandom";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.urandom";
    rf.short_name = "urandom";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.register_at_fork";
    rf.short_name = "register_at_fork";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.add_dll_directory";
    rf.short_name = "add_dll_directory";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.memfd_create";
    rf.short_name = "memfd_create";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.copy_file_range";
    rf.short_name = "copy_file_range";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.waitstatus_to_exitcode";
    rf.short_name = "waitstatus_to_exitcode";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.pidfd_open";
    rf.short_name = "pidfd_open";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.listdrives";
    rf.short_name = "listdrives";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.listmounts";
    rf.short_name = "listmounts";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.listvolumes";
    rf.short_name = "listvolumes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.eventfd";
    rf.short_name = "eventfd";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.eventfd_read";
    rf.short_name = "eventfd_read";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.eventfd_write";
    rf.short_name = "eventfd_write";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.splice";
    rf.short_name = "splice";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.unshare";
    rf.short_name = "unshare";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.setns";
    rf.short_name = "setns";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.posix_openpt";
    rf.short_name = "posix_openpt";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.grantpt";
    rf.short_name = "grantpt";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.unlockpt";
    rf.short_name = "unlockpt";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.ptsname";
    rf.short_name = "ptsname";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.timerfd_create";
    rf.short_name = "timerfd_create";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.timerfd_settime";
    rf.short_name = "timerfd_settime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.timerfd_settime_ns";
    rf.short_name = "timerfd_settime_ns";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.timerfd_gettime";
    rf.short_name = "timerfd_gettime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.timerfd_gettime_ns";
    rf.short_name = "timerfd_gettime_ns";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fchmod";
    rf.short_name = "fchmod";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.lchmod";
    rf.short_name = "lchmod";
    cbm_registry_add_func(reg, rf);

    /* ===== module: os.path ===== */
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.join";
    rf.short_name = "join";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.realpath";
    rf.short_name = "realpath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.isreserved";
    rf.short_name = "isreserved";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.abspath";
    rf.short_name = "abspath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.basename";
    rf.short_name = "basename";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.dirname";
    rf.short_name = "dirname";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.expanduser";
    rf.short_name = "expanduser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.expandvars";
    rf.short_name = "expandvars";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.normcase";
    rf.short_name = "normcase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.normpath";
    rf.short_name = "normpath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.commonpath";
    rf.short_name = "commonpath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.relpath";
    rf.short_name = "relpath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.split";
    rf.short_name = "split";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.splitdrive";
    rf.short_name = "splitdrive";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.splitext";
    rf.short_name = "splitext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.isabs";
    rf.short_name = "isabs";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.islink";
    rf.short_name = "islink";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.ismount";
    rf.short_name = "ismount";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.lexists";
    rf.short_name = "lexists";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.isjunction";
    rf.short_name = "isjunction";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.path.splitroot";
    rf.short_name = "splitroot";
    cbm_registry_add_func(reg, rf);

    /* ===== module: pathlib ===== */
    static const char* py_methods_737[] = { "full_match", "parts", "drive", "root", "anchor", "name", "suffix", "suffixes", "stem", "__new__", "__init__", "as_posix", "as_uri", "is_absolute", "is_reserved", "is_relative_to", "match", "relative_to", "with_name", "with_stem", "with_suffix", "joinpath", "parents", "parent", "__class_getitem__", "with_segments", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "pathlib.PurePath";
    rt.short_name = "PurePath";
    rt.method_names = py_methods_737;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.full_match";
    rf.short_name = "full_match";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.parts";
    rf.short_name = "parts";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.drive";
    rf.short_name = "drive";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.root";
    rf.short_name = "root";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.anchor";
    rf.short_name = "anchor";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.name";
    rf.short_name = "name";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.suffix";
    rf.short_name = "suffix";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.suffixes";
    rf.short_name = "suffixes";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.stem";
    rf.short_name = "stem";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.__new__";
    rf.short_name = "__new__";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.as_posix";
    rf.short_name = "as_posix";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.as_uri";
    rf.short_name = "as_uri";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.is_absolute";
    rf.short_name = "is_absolute";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.is_reserved";
    rf.short_name = "is_reserved";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.is_relative_to";
    rf.short_name = "is_relative_to";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.match";
    rf.short_name = "match";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.relative_to";
    rf.short_name = "relative_to";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.with_name";
    rf.short_name = "with_name";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.with_stem";
    rf.short_name = "with_stem";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.with_suffix";
    rf.short_name = "with_suffix";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.joinpath";
    rf.short_name = "joinpath";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.parents";
    rf.short_name = "parents";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.parent";
    rf.short_name = "parent";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.__class_getitem__";
    rf.short_name = "__class_getitem__";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.PurePath.with_segments";
    rf.short_name = "with_segments";
    rf.receiver_type = "pathlib.PurePath";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "pathlib.PurePosixPath";
    rt.short_name = "PurePosixPath";
    static const char* py_bases_738[] = { "pathlib.PurePath", NULL };
    rt.embedded_types = py_bases_738;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "pathlib.PureWindowsPath";
    rt.short_name = "PureWindowsPath";
    static const char* py_bases_739[] = { "pathlib.PurePath", NULL };
    rt.embedded_types = py_bases_739;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_740[] = { "__new__", "cwd", "stat", "chmod", "from_uri", "is_dir", "is_file", "read_text", "__enter__", "__exit__", "glob", "rglob", "exists", "is_symlink", "is_socket", "is_fifo", "is_block_device", "is_char_device", "is_junction", "iterdir", "lchmod", "lstat", "mkdir", "info", "move_into", "move", "copy_into", "copy", "open", "is_mount", "readlink", "rename", "replace", "resolve", "rmdir", "symlink_to", "hardlink_to", "touch", "unlink", "home", "absolute", "expanduser", "read_bytes", "samefile", "write_bytes", "write_text", "link_to", "walk", "as_uri", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "pathlib.Path";
    rt.short_name = "Path";
    rt.method_names = py_methods_740;
    static const char* py_bases_741[] = { "pathlib.PurePath", NULL };
    rt.embedded_types = py_bases_741;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.__new__";
    rf.short_name = "__new__";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.cwd";
    rf.short_name = "cwd";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.stat";
    rf.short_name = "stat";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.chmod";
    rf.short_name = "chmod";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.from_uri";
    rf.short_name = "from_uri";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.is_dir";
    rf.short_name = "is_dir";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.is_file";
    rf.short_name = "is_file";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.read_text";
    rf.short_name = "read_text";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.glob";
    rf.short_name = "glob";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.rglob";
    rf.short_name = "rglob";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.exists";
    rf.short_name = "exists";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.is_symlink";
    rf.short_name = "is_symlink";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.is_socket";
    rf.short_name = "is_socket";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.is_fifo";
    rf.short_name = "is_fifo";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.is_block_device";
    rf.short_name = "is_block_device";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.is_char_device";
    rf.short_name = "is_char_device";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.is_junction";
    rf.short_name = "is_junction";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.iterdir";
    rf.short_name = "iterdir";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.lchmod";
    rf.short_name = "lchmod";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.lstat";
    rf.short_name = "lstat";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.mkdir";
    rf.short_name = "mkdir";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.info";
    rf.short_name = "info";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.move_into";
    rf.short_name = "move_into";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.move";
    rf.short_name = "move";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.copy_into";
    rf.short_name = "copy_into";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.copy";
    rf.short_name = "copy";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.open";
    rf.short_name = "open";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.is_mount";
    rf.short_name = "is_mount";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.readlink";
    rf.short_name = "readlink";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.rename";
    rf.short_name = "rename";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.replace";
    rf.short_name = "replace";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.resolve";
    rf.short_name = "resolve";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.rmdir";
    rf.short_name = "rmdir";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.symlink_to";
    rf.short_name = "symlink_to";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.hardlink_to";
    rf.short_name = "hardlink_to";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.touch";
    rf.short_name = "touch";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.unlink";
    rf.short_name = "unlink";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.home";
    rf.short_name = "home";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.absolute";
    rf.short_name = "absolute";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.expanduser";
    rf.short_name = "expanduser";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.read_bytes";
    rf.short_name = "read_bytes";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.samefile";
    rf.short_name = "samefile";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.write_bytes";
    rf.short_name = "write_bytes";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.write_text";
    rf.short_name = "write_text";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.link_to";
    rf.short_name = "link_to";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.walk";
    rf.short_name = "walk";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.Path.as_uri";
    rf.short_name = "as_uri";
    rf.receiver_type = "pathlib.Path";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "pathlib.PosixPath";
    rt.short_name = "PosixPath";
    static const char* py_bases_742[] = { "pathlib.Path", "pathlib.PurePosixPath", NULL };
    rt.embedded_types = py_bases_742;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "pathlib.WindowsPath";
    rt.short_name = "WindowsPath";
    static const char* py_bases_743[] = { "pathlib.Path", "pathlib.PureWindowsPath", NULL };
    rt.embedded_types = py_bases_743;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "pathlib.UnsupportedOperation";
    rt.short_name = "UnsupportedOperation";
    static const char* py_bases_744[] = { "pathlib.NotImplementedError", NULL };
    rt.embedded_types = py_bases_744;
    cbm_registry_add_type(reg, rt);

    /* ===== module: pathlib.types ===== */
    static const char* py_methods_745[] = { "exists", "is_dir", "is_file", "is_symlink", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "pathlib.types.PathInfo";
    rt.short_name = "PathInfo";
    rt.method_names = py_methods_745;
    static const char* py_bases_746[] = { "pathlib.types.Protocol", NULL };
    rt.embedded_types = py_bases_746;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.types.PathInfo.exists";
    rf.short_name = "exists";
    rf.receiver_type = "pathlib.types.PathInfo";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.types.PathInfo.is_dir";
    rf.short_name = "is_dir";
    rf.receiver_type = "pathlib.types.PathInfo";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.types.PathInfo.is_file";
    rf.short_name = "is_file";
    rf.receiver_type = "pathlib.types.PathInfo";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pathlib.types.PathInfo.is_symlink";
    rf.short_name = "is_symlink";
    rf.receiver_type = "pathlib.types.PathInfo";
    cbm_registry_add_func(reg, rf);

    /* ===== module: pickle ===== */
    static const char* py_methods_747[] = { "raw", "release", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "pickle.PickleBuffer";
    rt.short_name = "PickleBuffer";
    rt.method_names = py_methods_747;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pickle.PickleBuffer.raw";
    rf.short_name = "raw";
    rf.receiver_type = "pickle.PickleBuffer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pickle.PickleBuffer.release";
    rf.short_name = "release";
    rf.receiver_type = "pickle.PickleBuffer";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_748[] = { "__init__", "dump", "clear_memo", "persistent_id", "reducer_override", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "pickle._Pickler";
    rt.short_name = "_Pickler";
    rt.method_names = py_methods_748;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pickle._Pickler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "pickle._Pickler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pickle._Pickler.dump";
    rf.short_name = "dump";
    rf.receiver_type = "pickle._Pickler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pickle._Pickler.clear_memo";
    rf.short_name = "clear_memo";
    rf.receiver_type = "pickle._Pickler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pickle._Pickler.persistent_id";
    rf.short_name = "persistent_id";
    rf.receiver_type = "pickle._Pickler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pickle._Pickler.reducer_override";
    rf.short_name = "reducer_override";
    rf.receiver_type = "pickle._Pickler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_749[] = { "__init__", "load", "find_class", "persistent_load", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "pickle._Unpickler";
    rt.short_name = "_Unpickler";
    rt.method_names = py_methods_749;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pickle._Unpickler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "pickle._Unpickler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pickle._Unpickler.load";
    rf.short_name = "load";
    rf.receiver_type = "pickle._Unpickler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pickle._Unpickler.find_class";
    rf.short_name = "find_class";
    rf.receiver_type = "pickle._Unpickler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pickle._Unpickler.persistent_load";
    rf.short_name = "persistent_load";
    rf.receiver_type = "pickle._Unpickler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pickle.encode_long";
    rf.short_name = "encode_long";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "pickle.decode_long";
    rf.short_name = "decode_long";
    cbm_registry_add_func(reg, rf);

    /* ===== module: posixpath ===== */
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "posixpath.abspath";
    rf.short_name = "abspath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "posixpath.basename";
    rf.short_name = "basename";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "posixpath.dirname";
    rf.short_name = "dirname";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "posixpath.expanduser";
    rf.short_name = "expanduser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "posixpath.expandvars";
    rf.short_name = "expandvars";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "posixpath.normcase";
    rf.short_name = "normcase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "posixpath.normpath";
    rf.short_name = "normpath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "posixpath.commonpath";
    rf.short_name = "commonpath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "posixpath.join";
    rf.short_name = "join";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "posixpath.realpath";
    rf.short_name = "realpath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "posixpath.relpath";
    rf.short_name = "relpath";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "posixpath.split";
    rf.short_name = "split";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "posixpath.splitdrive";
    rf.short_name = "splitdrive";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "posixpath.splitext";
    rf.short_name = "splitext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "posixpath.isabs";
    rf.short_name = "isabs";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "posixpath.islink";
    rf.short_name = "islink";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "posixpath.ismount";
    rf.short_name = "ismount";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "posixpath.lexists";
    rf.short_name = "lexists";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "posixpath.isjunction";
    rf.short_name = "isjunction";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "posixpath.splitroot";
    rf.short_name = "splitroot";
    cbm_registry_add_func(reg, rf);

    /* ===== module: queue ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "queue.Full";
    rt.short_name = "Full";
    static const char* py_bases_750[] = { "queue.Exception", NULL };
    rt.embedded_types = py_bases_750;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "queue.ShutDown";
    rt.short_name = "ShutDown";
    static const char* py_bases_751[] = { "queue.Exception", NULL };
    rt.embedded_types = py_bases_751;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_752[] = { "__init__", "empty", "full", "get", "get_nowait", "shutdown", "put", "put_nowait", "join", "qsize", "task_done", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "queue.Queue";
    rt.short_name = "Queue";
    rt.method_names = py_methods_752;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "queue.Queue.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "queue.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "queue.Queue.empty";
    rf.short_name = "empty";
    rf.receiver_type = "queue.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "queue.Queue.full";
    rf.short_name = "full";
    rf.receiver_type = "queue.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "queue.Queue.get";
    rf.short_name = "get";
    rf.receiver_type = "queue.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "queue.Queue.get_nowait";
    rf.short_name = "get_nowait";
    rf.receiver_type = "queue.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "queue.Queue.shutdown";
    rf.short_name = "shutdown";
    rf.receiver_type = "queue.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "queue.Queue.put";
    rf.short_name = "put";
    rf.receiver_type = "queue.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "queue.Queue.put_nowait";
    rf.short_name = "put_nowait";
    rf.receiver_type = "queue.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "queue.Queue.join";
    rf.short_name = "join";
    rf.receiver_type = "queue.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "queue.Queue.qsize";
    rf.short_name = "qsize";
    rf.receiver_type = "queue.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "queue.Queue.task_done";
    rf.short_name = "task_done";
    rf.receiver_type = "queue.Queue";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "queue.PriorityQueue";
    rt.short_name = "PriorityQueue";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "queue.LifoQueue";
    rt.short_name = "LifoQueue";
    cbm_registry_add_type(reg, rt);

    /* ===== module: re ===== */
    static const char* py_methods_753[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "re.error";
    rt.short_name = "error";
    rt.method_names = py_methods_753;
    static const char* py_bases_754[] = { "re.Exception", NULL };
    rt.embedded_types = py_bases_754;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.error.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "re.error";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_755[] = { "pos", "endpos", "lastindex", "lastgroup", "string", "re", "expand", "group", "groups", "groupdict", "start", "end", "span", "regs", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "re.Match";
    rt.short_name = "Match";
    rt.method_names = py_methods_755;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Match.pos";
    rf.short_name = "pos";
    rf.receiver_type = "re.Match";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Match.endpos";
    rf.short_name = "endpos";
    rf.receiver_type = "re.Match";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Match.lastindex";
    rf.short_name = "lastindex";
    rf.receiver_type = "re.Match";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Match.lastgroup";
    rf.short_name = "lastgroup";
    rf.receiver_type = "re.Match";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Match.string";
    rf.short_name = "string";
    rf.receiver_type = "re.Match";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Match.re";
    rf.short_name = "re";
    rf.receiver_type = "re.Match";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Match.expand";
    rf.short_name = "expand";
    rf.receiver_type = "re.Match";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Match.group";
    rf.short_name = "group";
    rf.receiver_type = "re.Match";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Match.groups";
    rf.short_name = "groups";
    rf.receiver_type = "re.Match";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Match.groupdict";
    rf.short_name = "groupdict";
    rf.receiver_type = "re.Match";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Match.start";
    rf.short_name = "start";
    rf.receiver_type = "re.Match";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Match.end";
    rf.short_name = "end";
    rf.receiver_type = "re.Match";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Match.span";
    rf.short_name = "span";
    rf.receiver_type = "re.Match";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Match.regs";
    rf.short_name = "regs";
    rf.receiver_type = "re.Match";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_756[] = { "flags", "groupindex", "groups", "pattern", "search", "match", "fullmatch", "split", "findall", "finditer", "sub", "subn", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "re.Pattern";
    rt.short_name = "Pattern";
    rt.method_names = py_methods_756;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Pattern.flags";
    rf.short_name = "flags";
    rf.receiver_type = "re.Pattern";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Pattern.groupindex";
    rf.short_name = "groupindex";
    rf.receiver_type = "re.Pattern";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Pattern.groups";
    rf.short_name = "groups";
    rf.receiver_type = "re.Pattern";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Pattern.pattern";
    rf.short_name = "pattern";
    rf.receiver_type = "re.Pattern";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Pattern.search";
    rf.short_name = "search";
    rf.receiver_type = "re.Pattern";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Pattern.match";
    rf.short_name = "match";
    rf.receiver_type = "re.Pattern";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Pattern.fullmatch";
    rf.short_name = "fullmatch";
    rf.receiver_type = "re.Pattern";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Pattern.split";
    rf.short_name = "split";
    rf.receiver_type = "re.Pattern";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Pattern.findall";
    rf.short_name = "findall";
    rf.receiver_type = "re.Pattern";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Pattern.finditer";
    rf.short_name = "finditer";
    rf.receiver_type = "re.Pattern";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Pattern.sub";
    rf.short_name = "sub";
    rf.receiver_type = "re.Pattern";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.Pattern.subn";
    rf.short_name = "subn";
    rf.receiver_type = "re.Pattern";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "re.RegexFlag";
    rt.short_name = "RegexFlag";
    static const char* py_bases_757[] = { "enum.IntFlag", NULL };
    rt.embedded_types = py_bases_757;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.compile";
    rf.short_name = "compile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.search";
    rf.short_name = "search";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.match";
    rf.short_name = "match";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.fullmatch";
    rf.short_name = "fullmatch";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.split";
    rf.short_name = "split";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.findall";
    rf.short_name = "findall";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.finditer";
    rf.short_name = "finditer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.sub";
    rf.short_name = "sub";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.subn";
    rf.short_name = "subn";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.escape";
    rf.short_name = "escape";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.purge";
    rf.short_name = "purge";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "re.template";
    rf.short_name = "template";
    cbm_registry_add_func(reg, rf);

    /* ===== module: shutil ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "shutil.Error";
    rt.short_name = "Error";
    static const char* py_bases_758[] = { "shutil.OSError", NULL };
    rt.embedded_types = py_bases_758;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "shutil.SameFileError";
    rt.short_name = "SameFileError";
    static const char* py_bases_759[] = { "shutil.Error", NULL };
    rt.embedded_types = py_bases_759;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "shutil.SpecialFileError";
    rt.short_name = "SpecialFileError";
    static const char* py_bases_760[] = { "shutil.OSError", NULL };
    rt.embedded_types = py_bases_760;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "shutil.ExecError";
    rt.short_name = "ExecError";
    static const char* py_bases_761[] = { "shutil.OSError", NULL };
    rt.embedded_types = py_bases_761;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "shutil.ReadError";
    rt.short_name = "ReadError";
    static const char* py_bases_762[] = { "shutil.OSError", NULL };
    rt.embedded_types = py_bases_762;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "shutil.RegistryError";
    rt.short_name = "RegistryError";
    static const char* py_bases_763[] = { "shutil.Exception", NULL };
    rt.embedded_types = py_bases_763;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_764[] = { "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "shutil._RmtreeType";
    rt.short_name = "_RmtreeType";
    rt.method_names = py_methods_764;
    static const char* py_bases_765[] = { "shutil.Protocol", NULL };
    rt.embedded_types = py_bases_765;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil._RmtreeType.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "shutil._RmtreeType";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "shutil._ntuple_diskusage";
    rt.short_name = "_ntuple_diskusage";
    static const char* py_bases_766[] = { "shutil.NamedTuple", NULL };
    rt.embedded_types = py_bases_766;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.copyfileobj";
    rf.short_name = "copyfileobj";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.copyfile";
    rf.short_name = "copyfile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.copymode";
    rf.short_name = "copymode";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.copystat";
    rf.short_name = "copystat";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.copy";
    rf.short_name = "copy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.copy2";
    rf.short_name = "copy2";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.ignore_patterns";
    rf.short_name = "ignore_patterns";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.copytree";
    rf.short_name = "copytree";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.move";
    rf.short_name = "move";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.disk_usage";
    rf.short_name = "disk_usage";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.chown";
    rf.short_name = "chown";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.which";
    rf.short_name = "which";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.make_archive";
    rf.short_name = "make_archive";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.get_archive_formats";
    rf.short_name = "get_archive_formats";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.register_archive_format";
    rf.short_name = "register_archive_format";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.unregister_archive_format";
    rf.short_name = "unregister_archive_format";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.unpack_archive";
    rf.short_name = "unpack_archive";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.register_unpack_format";
    rf.short_name = "register_unpack_format";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.unregister_unpack_format";
    rf.short_name = "unregister_unpack_format";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.get_unpack_formats";
    rf.short_name = "get_unpack_formats";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "shutil.get_terminal_size";
    rf.short_name = "get_terminal_size";
    cbm_registry_add_func(reg, rf);

    /* ===== module: socket ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "socket.herror";
    rt.short_name = "herror";
    static const char* py_bases_767[] = { "socket.error", NULL };
    rt.embedded_types = py_bases_767;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "socket.gaierror";
    rt.short_name = "gaierror";
    static const char* py_bases_768[] = { "socket.error", NULL };
    rt.embedded_types = py_bases_768;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "socket.AddressFamily";
    rt.short_name = "AddressFamily";
    static const char* py_bases_769[] = { "socket.IntEnum", NULL };
    rt.embedded_types = py_bases_769;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "socket.SocketKind";
    rt.short_name = "SocketKind";
    static const char* py_bases_770[] = { "socket.IntEnum", NULL };
    rt.embedded_types = py_bases_770;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "socket.MsgFlag";
    rt.short_name = "MsgFlag";
    static const char* py_bases_771[] = { "socket.IntFlag", NULL };
    rt.embedded_types = py_bases_771;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "socket.AddressInfo";
    rt.short_name = "AddressInfo";
    static const char* py_bases_772[] = { "socket.IntFlag", NULL };
    rt.embedded_types = py_bases_772;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_773[] = { "read", "seek", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "socket._SendableFile";
    rt.short_name = "_SendableFile";
    rt.method_names = py_methods_773;
    static const char* py_bases_774[] = { "socket.Protocol", NULL };
    rt.embedded_types = py_bases_774;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket._SendableFile.read";
    rf.short_name = "read";
    rf.receiver_type = "socket._SendableFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket._SendableFile.seek";
    rf.short_name = "seek";
    rf.receiver_type = "socket._SendableFile";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_775[] = { "__init__", "__enter__", "__exit__", "dup", "accept", "makefile", "sendfile", "family", "type", "get_inheritable", "set_inheritable", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "socket.socket";
    rt.short_name = "socket";
    rt.method_names = py_methods_775;
    static const char* py_bases_776[] = { "_socket.socket", NULL };
    rt.embedded_types = py_bases_776;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.socket.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "socket.socket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.socket.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "socket.socket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.socket.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "socket.socket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.socket.dup";
    rf.short_name = "dup";
    rf.receiver_type = "socket.socket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.socket.accept";
    rf.short_name = "accept";
    rf.receiver_type = "socket.socket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.socket.makefile";
    rf.short_name = "makefile";
    rf.receiver_type = "socket.socket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.socket.sendfile";
    rf.short_name = "sendfile";
    rf.receiver_type = "socket.socket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.socket.family";
    rf.short_name = "family";
    rf.receiver_type = "socket.socket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.socket.type";
    rf.short_name = "type";
    rf.receiver_type = "socket.socket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.socket.get_inheritable";
    rf.short_name = "get_inheritable";
    rf.receiver_type = "socket.socket";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.socket.set_inheritable";
    rf.short_name = "set_inheritable";
    rf.receiver_type = "socket.socket";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_777[] = { "__init__", "readinto", "write", "name", "mode", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "socket.SocketIO";
    rt.short_name = "SocketIO";
    rt.method_names = py_methods_777;
    static const char* py_bases_778[] = { "socket.RawIOBase", NULL };
    rt.embedded_types = py_bases_778;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.SocketIO.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "socket.SocketIO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.SocketIO.readinto";
    rf.short_name = "readinto";
    rf.receiver_type = "socket.SocketIO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.SocketIO.write";
    rf.short_name = "write";
    rf.receiver_type = "socket.SocketIO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.SocketIO.name";
    rf.short_name = "name";
    rf.receiver_type = "socket.SocketIO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.SocketIO.mode";
    rf.short_name = "mode";
    rf.receiver_type = "socket.SocketIO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.fromfd";
    rf.short_name = "fromfd";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.send_fds";
    rf.short_name = "send_fds";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.recv_fds";
    rf.short_name = "recv_fds";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.fromshare";
    rf.short_name = "fromshare";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.socketpair";
    rf.short_name = "socketpair";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.getfqdn";
    rf.short_name = "getfqdn";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.create_connection";
    rf.short_name = "create_connection";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.has_dualstack_ipv6";
    rf.short_name = "has_dualstack_ipv6";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.create_server";
    rf.short_name = "create_server";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "socket.getaddrinfo";
    rf.short_name = "getaddrinfo";
    cbm_registry_add_func(reg, rf);

    /* ===== module: string ===== */
    static const char* py_methods_779[] = { "__init__", "substitute", "safe_substitute", "get_identifiers", "is_valid", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "string.Template";
    rt.short_name = "Template";
    rt.method_names = py_methods_779;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "string.Template.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "string.Template";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "string.Template.substitute";
    rf.short_name = "substitute";
    rf.receiver_type = "string.Template";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "string.Template.safe_substitute";
    rf.short_name = "safe_substitute";
    rf.receiver_type = "string.Template";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "string.Template.get_identifiers";
    rf.short_name = "get_identifiers";
    rf.receiver_type = "string.Template";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "string.Template.is_valid";
    rf.short_name = "is_valid";
    rf.receiver_type = "string.Template";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_780[] = { "format", "vformat", "parse", "get_field", "get_value", "check_unused_args", "format_field", "convert_field", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "string.Formatter";
    rt.short_name = "Formatter";
    rt.method_names = py_methods_780;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "string.Formatter.format";
    rf.short_name = "format";
    rf.receiver_type = "string.Formatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "string.Formatter.vformat";
    rf.short_name = "vformat";
    rf.receiver_type = "string.Formatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "string.Formatter.parse";
    rf.short_name = "parse";
    rf.receiver_type = "string.Formatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "string.Formatter.get_field";
    rf.short_name = "get_field";
    rf.receiver_type = "string.Formatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "string.Formatter.get_value";
    rf.short_name = "get_value";
    rf.receiver_type = "string.Formatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "string.Formatter.check_unused_args";
    rf.short_name = "check_unused_args";
    rf.receiver_type = "string.Formatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "string.Formatter.format_field";
    rf.short_name = "format_field";
    rf.receiver_type = "string.Formatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "string.Formatter.convert_field";
    rf.short_name = "convert_field";
    rf.receiver_type = "string.Formatter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "string.capwords";
    rf.short_name = "capwords";
    cbm_registry_add_func(reg, rf);

    /* ===== module: string.templatelib ===== */
    static const char* py_methods_781[] = { "values", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "string.templatelib.Template";
    rt.short_name = "Template";
    rt.method_names = py_methods_781;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "string.templatelib.Template.values";
    rf.short_name = "values";
    rf.receiver_type = "string.templatelib.Template";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "string.templatelib.Interpolation";
    rt.short_name = "Interpolation";
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "string.templatelib.convert";
    rf.short_name = "convert";
    cbm_registry_add_func(reg, rf);

    /* ===== module: subprocess ===== */
    static const char* py_methods_782[] = { "__init__", "check_returncode", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "subprocess.CompletedProcess";
    rt.short_name = "CompletedProcess";
    rt.method_names = py_methods_782;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.CompletedProcess.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "subprocess.CompletedProcess";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.CompletedProcess.check_returncode";
    rf.short_name = "check_returncode";
    rf.receiver_type = "subprocess.CompletedProcess";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "subprocess.SubprocessError";
    rt.short_name = "SubprocessError";
    static const char* py_bases_783[] = { "subprocess.Exception", NULL };
    rt.embedded_types = py_bases_783;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_784[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "subprocess.TimeoutExpired";
    rt.short_name = "TimeoutExpired";
    rt.method_names = py_methods_784;
    static const char* py_bases_785[] = { "subprocess.SubprocessError", NULL };
    rt.embedded_types = py_bases_785;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.TimeoutExpired.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "subprocess.TimeoutExpired";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_786[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "subprocess.CalledProcessError";
    rt.short_name = "CalledProcessError";
    rt.method_names = py_methods_786;
    static const char* py_bases_787[] = { "subprocess.SubprocessError", NULL };
    rt.embedded_types = py_bases_787;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.CalledProcessError.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "subprocess.CalledProcessError";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_788[] = { "__init__", "poll", "wait", "communicate", "send_signal", "terminate", "kill", "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "subprocess.Popen";
    rt.short_name = "Popen";
    rt.method_names = py_methods_788;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.Popen.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "subprocess.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.Popen.poll";
    rf.short_name = "poll";
    rf.receiver_type = "subprocess.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.Popen.wait";
    rf.short_name = "wait";
    rf.receiver_type = "subprocess.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.Popen.communicate";
    rf.short_name = "communicate";
    rf.receiver_type = "subprocess.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.Popen.send_signal";
    rf.short_name = "send_signal";
    rf.receiver_type = "subprocess.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.Popen.terminate";
    rf.short_name = "terminate";
    rf.receiver_type = "subprocess.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.Popen.kill";
    rf.short_name = "kill";
    rf.receiver_type = "subprocess.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.Popen.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "subprocess.Popen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.Popen.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "subprocess.Popen";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_789[] = { "__init__", "copy", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "subprocess.STARTUPINFO";
    rt.short_name = "STARTUPINFO";
    rt.method_names = py_methods_789;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.STARTUPINFO.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "subprocess.STARTUPINFO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.STARTUPINFO.copy";
    rf.short_name = "copy";
    rf.receiver_type = "subprocess.STARTUPINFO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.run";
    rf.short_name = "run";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.call";
    rf.short_name = "call";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.check_call";
    rf.short_name = "check_call";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.check_output";
    rf.short_name = "check_output";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.getstatusoutput";
    rf.short_name = "getstatusoutput";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.getoutput";
    rf.short_name = "getoutput";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "subprocess.list2cmdline";
    rf.short_name = "list2cmdline";
    cbm_registry_add_func(reg, rf);

    /* ===== module: sys ===== */
    static const char* py_methods_790[] = { "debug", "inspect", "interactive", "optimize", "dont_write_bytecode", "no_user_site", "no_site", "ignore_environment", "verbose", "bytes_warning", "quiet", "hash_randomization", "isolated", "dev_mode", "utf8_mode", "warn_default_encoding", "safe_path", "gil", "thread_inherit_context", "context_aware_warnings", "int_max_str_digits", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sys._flags";
    rt.short_name = "_flags";
    rt.method_names = py_methods_790;
    static const char* py_bases_791[] = { "sys._UninstantiableStructseq", NULL };
    rt.embedded_types = py_bases_791;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.debug";
    rf.short_name = "debug";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.inspect";
    rf.short_name = "inspect";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.interactive";
    rf.short_name = "interactive";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.optimize";
    rf.short_name = "optimize";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.dont_write_bytecode";
    rf.short_name = "dont_write_bytecode";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.no_user_site";
    rf.short_name = "no_user_site";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.no_site";
    rf.short_name = "no_site";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.ignore_environment";
    rf.short_name = "ignore_environment";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.verbose";
    rf.short_name = "verbose";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.bytes_warning";
    rf.short_name = "bytes_warning";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.quiet";
    rf.short_name = "quiet";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.hash_randomization";
    rf.short_name = "hash_randomization";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.isolated";
    rf.short_name = "isolated";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.dev_mode";
    rf.short_name = "dev_mode";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.utf8_mode";
    rf.short_name = "utf8_mode";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.warn_default_encoding";
    rf.short_name = "warn_default_encoding";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.safe_path";
    rf.short_name = "safe_path";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.gil";
    rf.short_name = "gil";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.thread_inherit_context";
    rf.short_name = "thread_inherit_context";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.context_aware_warnings";
    rf.short_name = "context_aware_warnings";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._flags.int_max_str_digits";
    rf.short_name = "int_max_str_digits";
    rf.receiver_type = "sys._flags";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_792[] = { "max", "max_exp", "max_10_exp", "min", "min_exp", "min_10_exp", "dig", "mant_dig", "epsilon", "radix", "rounds", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sys._float_info";
    rt.short_name = "_float_info";
    rt.method_names = py_methods_792;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._float_info.max";
    rf.short_name = "max";
    rf.receiver_type = "sys._float_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._float_info.max_exp";
    rf.short_name = "max_exp";
    rf.receiver_type = "sys._float_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._float_info.max_10_exp";
    rf.short_name = "max_10_exp";
    rf.receiver_type = "sys._float_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._float_info.min";
    rf.short_name = "min";
    rf.receiver_type = "sys._float_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._float_info.min_exp";
    rf.short_name = "min_exp";
    rf.receiver_type = "sys._float_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._float_info.min_10_exp";
    rf.short_name = "min_10_exp";
    rf.receiver_type = "sys._float_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._float_info.dig";
    rf.short_name = "dig";
    rf.receiver_type = "sys._float_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._float_info.mant_dig";
    rf.short_name = "mant_dig";
    rf.receiver_type = "sys._float_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._float_info.epsilon";
    rf.short_name = "epsilon";
    rf.receiver_type = "sys._float_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._float_info.radix";
    rf.short_name = "radix";
    rf.receiver_type = "sys._float_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._float_info.rounds";
    rf.short_name = "rounds";
    rf.receiver_type = "sys._float_info";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_793[] = { "width", "modulus", "inf", "nan", "imag", "algorithm", "hash_bits", "seed_bits", "cutoff", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sys._hash_info";
    rt.short_name = "_hash_info";
    rt.method_names = py_methods_793;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._hash_info.width";
    rf.short_name = "width";
    rf.receiver_type = "sys._hash_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._hash_info.modulus";
    rf.short_name = "modulus";
    rf.receiver_type = "sys._hash_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._hash_info.inf";
    rf.short_name = "inf";
    rf.receiver_type = "sys._hash_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._hash_info.nan";
    rf.short_name = "nan";
    rf.receiver_type = "sys._hash_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._hash_info.imag";
    rf.short_name = "imag";
    rf.receiver_type = "sys._hash_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._hash_info.algorithm";
    rf.short_name = "algorithm";
    rf.receiver_type = "sys._hash_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._hash_info.hash_bits";
    rf.short_name = "hash_bits";
    rf.receiver_type = "sys._hash_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._hash_info.seed_bits";
    rf.short_name = "seed_bits";
    rf.receiver_type = "sys._hash_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._hash_info.cutoff";
    rf.short_name = "cutoff";
    rf.receiver_type = "sys._hash_info";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sys._implementation";
    rt.short_name = "_implementation";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_794[] = { "bits_per_digit", "sizeof_digit", "default_max_str_digits", "str_digits_check_threshold", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sys._int_info";
    rt.short_name = "_int_info";
    rt.method_names = py_methods_794;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._int_info.bits_per_digit";
    rf.short_name = "bits_per_digit";
    rf.receiver_type = "sys._int_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._int_info.sizeof_digit";
    rf.short_name = "sizeof_digit";
    rf.receiver_type = "sys._int_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._int_info.default_max_str_digits";
    rf.short_name = "default_max_str_digits";
    rf.receiver_type = "sys._int_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._int_info.str_digits_check_threshold";
    rf.short_name = "str_digits_check_threshold";
    rf.receiver_type = "sys._int_info";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_795[] = { "name", "lock", "version", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sys._thread_info";
    rt.short_name = "_thread_info";
    rt.method_names = py_methods_795;
    static const char* py_bases_796[] = { "sys._UninstantiableStructseq", NULL };
    rt.embedded_types = py_bases_796;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._thread_info.name";
    rf.short_name = "name";
    rf.receiver_type = "sys._thread_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._thread_info.lock";
    rf.short_name = "lock";
    rf.receiver_type = "sys._thread_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._thread_info.version";
    rf.short_name = "version";
    rf.receiver_type = "sys._thread_info";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_797[] = { "major", "minor", "micro", "releaselevel", "serial", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sys._version_info";
    rt.short_name = "_version_info";
    rt.method_names = py_methods_797;
    static const char* py_bases_798[] = { "sys._UninstantiableStructseq", NULL };
    rt.embedded_types = py_bases_798;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._version_info.major";
    rf.short_name = "major";
    rf.receiver_type = "sys._version_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._version_info.minor";
    rf.short_name = "minor";
    rf.receiver_type = "sys._version_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._version_info.micro";
    rf.short_name = "micro";
    rf.receiver_type = "sys._version_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._version_info.releaselevel";
    rf.short_name = "releaselevel";
    rf.receiver_type = "sys._version_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._version_info.serial";
    rf.short_name = "serial";
    rf.receiver_type = "sys._version_info";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_799[] = { "major", "minor", "build", "platform", "service_pack", "service_pack_minor", "service_pack_major", "suite_mask", "product_type", "platform_version", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sys._WinVersion";
    rt.short_name = "_WinVersion";
    rt.method_names = py_methods_799;
    static const char* py_bases_800[] = { "sys._UninstantiableStructseq", NULL };
    rt.embedded_types = py_bases_800;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._WinVersion.major";
    rf.short_name = "major";
    rf.receiver_type = "sys._WinVersion";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._WinVersion.minor";
    rf.short_name = "minor";
    rf.receiver_type = "sys._WinVersion";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._WinVersion.build";
    rf.short_name = "build";
    rf.receiver_type = "sys._WinVersion";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._WinVersion.platform";
    rf.short_name = "platform";
    rf.receiver_type = "sys._WinVersion";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._WinVersion.service_pack";
    rf.short_name = "service_pack";
    rf.receiver_type = "sys._WinVersion";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._WinVersion.service_pack_minor";
    rf.short_name = "service_pack_minor";
    rf.receiver_type = "sys._WinVersion";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._WinVersion.service_pack_major";
    rf.short_name = "service_pack_major";
    rf.receiver_type = "sys._WinVersion";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._WinVersion.suite_mask";
    rf.short_name = "suite_mask";
    rf.receiver_type = "sys._WinVersion";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._WinVersion.product_type";
    rf.short_name = "product_type";
    rf.receiver_type = "sys._WinVersion";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._WinVersion.platform_version";
    rf.short_name = "platform_version";
    rf.receiver_type = "sys._WinVersion";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sys.UnraisableHookArgs";
    rt.short_name = "UnraisableHookArgs";
    static const char* py_bases_801[] = { "sys.Protocol", NULL };
    rt.embedded_types = py_bases_801;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_802[] = { "firstiter", "finalizer", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sys._asyncgen_hooks";
    rt.short_name = "_asyncgen_hooks";
    rt.method_names = py_methods_802;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._asyncgen_hooks.firstiter";
    rf.short_name = "firstiter";
    rf.receiver_type = "sys._asyncgen_hooks";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._asyncgen_hooks.finalizer";
    rf.short_name = "finalizer";
    rf.receiver_type = "sys._asyncgen_hooks";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.call_tracing";
    rf.short_name = "call_tracing";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.exc_info";
    rf.short_name = "exc_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.exception";
    rf.short_name = "exception";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.exit";
    rf.short_name = "exit";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.getandroidapilevel";
    rf.short_name = "getandroidapilevel";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.getallocatedblocks";
    rf.short_name = "getallocatedblocks";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.getdefaultencoding";
    rf.short_name = "getdefaultencoding";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.getdlopenflags";
    rf.short_name = "getdlopenflags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.getfilesystemencoding";
    rf.short_name = "getfilesystemencoding";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.getfilesystemencodeerrors";
    rf.short_name = "getfilesystemencodeerrors";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.getrefcount";
    rf.short_name = "getrefcount";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.getrecursionlimit";
    rf.short_name = "getrecursionlimit";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.getsizeof";
    rf.short_name = "getsizeof";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.getswitchinterval";
    rf.short_name = "getswitchinterval";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.getprofile";
    rf.short_name = "getprofile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.setprofile";
    rf.short_name = "setprofile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.gettrace";
    rf.short_name = "gettrace";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.settrace";
    rf.short_name = "settrace";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.getwindowsversion";
    rf.short_name = "getwindowsversion";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.intern";
    rf.short_name = "intern";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.is_finalizing";
    rf.short_name = "is_finalizing";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.breakpointhook";
    rf.short_name = "breakpointhook";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.setdlopenflags";
    rf.short_name = "setdlopenflags";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.setrecursionlimit";
    rf.short_name = "setrecursionlimit";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.setswitchinterval";
    rf.short_name = "setswitchinterval";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.gettotalrefcount";
    rf.short_name = "gettotalrefcount";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.addaudithook";
    rf.short_name = "addaudithook";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.audit";
    rf.short_name = "audit";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.get_asyncgen_hooks";
    rf.short_name = "get_asyncgen_hooks";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.set_asyncgen_hooks";
    rf.short_name = "set_asyncgen_hooks";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.get_coroutine_origin_tracking_depth";
    rf.short_name = "get_coroutine_origin_tracking_depth";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.set_coroutine_origin_tracking_depth";
    rf.short_name = "set_coroutine_origin_tracking_depth";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.set_int_max_str_digits";
    rf.short_name = "set_int_max_str_digits";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.get_int_max_str_digits";
    rf.short_name = "get_int_max_str_digits";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.getunicodeinternedsize";
    rf.short_name = "getunicodeinternedsize";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.deactivate_stack_trampoline";
    rf.short_name = "deactivate_stack_trampoline";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.is_stack_trampoline_active";
    rf.short_name = "is_stack_trampoline_active";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.activate_stack_trampoline";
    rf.short_name = "activate_stack_trampoline";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.is_remote_debug_enabled";
    rf.short_name = "is_remote_debug_enabled";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.remote_exec";
    rf.short_name = "remote_exec";
    cbm_registry_add_func(reg, rf);

    /* ===== module: sys.__jit ===== */
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.__jit.is_available";
    rf.short_name = "is_available";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.__jit.is_enabled";
    rf.short_name = "is_enabled";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys.__jit.is_active";
    rf.short_name = "is_active";
    cbm_registry_add_func(reg, rf);

    /* ===== module: sys._monitoring ===== */
    static const char* py_methods_803[] = { "BRANCH", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sys._monitoring._events";
    rt.short_name = "_events";
    rt.method_names = py_methods_803;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._monitoring._events.BRANCH";
    rf.short_name = "BRANCH";
    rf.receiver_type = "sys._monitoring._events";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._monitoring.use_tool_id";
    rf.short_name = "use_tool_id";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._monitoring.clear_tool_id";
    rf.short_name = "clear_tool_id";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._monitoring.free_tool_id";
    rf.short_name = "free_tool_id";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._monitoring.get_tool";
    rf.short_name = "get_tool";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._monitoring.get_events";
    rf.short_name = "get_events";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._monitoring.set_events";
    rf.short_name = "set_events";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._monitoring.get_local_events";
    rf.short_name = "get_local_events";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._monitoring.set_local_events";
    rf.short_name = "set_local_events";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._monitoring.restart_events";
    rf.short_name = "restart_events";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sys._monitoring.register_callback";
    rf.short_name = "register_callback";
    cbm_registry_add_func(reg, rf);

    /* ===== module: tempfile ===== */
    static const char* py_methods_804[] = { "__init__", "__enter__", "__exit__", "close", "fileno", "flush", "isatty", "read", "readable", "readline", "readlines", "seek", "seekable", "tell", "truncate", "writable", "write", "writelines", "closed", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "tempfile._TemporaryFileWrapper";
    rt.short_name = "_TemporaryFileWrapper";
    rt.method_names = py_methods_804;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile._TemporaryFileWrapper.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "tempfile._TemporaryFileWrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile._TemporaryFileWrapper.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "tempfile._TemporaryFileWrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile._TemporaryFileWrapper.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "tempfile._TemporaryFileWrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile._TemporaryFileWrapper.close";
    rf.short_name = "close";
    rf.receiver_type = "tempfile._TemporaryFileWrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile._TemporaryFileWrapper.fileno";
    rf.short_name = "fileno";
    rf.receiver_type = "tempfile._TemporaryFileWrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile._TemporaryFileWrapper.flush";
    rf.short_name = "flush";
    rf.receiver_type = "tempfile._TemporaryFileWrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile._TemporaryFileWrapper.isatty";
    rf.short_name = "isatty";
    rf.receiver_type = "tempfile._TemporaryFileWrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile._TemporaryFileWrapper.read";
    rf.short_name = "read";
    rf.receiver_type = "tempfile._TemporaryFileWrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile._TemporaryFileWrapper.readable";
    rf.short_name = "readable";
    rf.receiver_type = "tempfile._TemporaryFileWrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile._TemporaryFileWrapper.readline";
    rf.short_name = "readline";
    rf.receiver_type = "tempfile._TemporaryFileWrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile._TemporaryFileWrapper.readlines";
    rf.short_name = "readlines";
    rf.receiver_type = "tempfile._TemporaryFileWrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile._TemporaryFileWrapper.seek";
    rf.short_name = "seek";
    rf.receiver_type = "tempfile._TemporaryFileWrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile._TemporaryFileWrapper.seekable";
    rf.short_name = "seekable";
    rf.receiver_type = "tempfile._TemporaryFileWrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile._TemporaryFileWrapper.tell";
    rf.short_name = "tell";
    rf.receiver_type = "tempfile._TemporaryFileWrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile._TemporaryFileWrapper.truncate";
    rf.short_name = "truncate";
    rf.receiver_type = "tempfile._TemporaryFileWrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile._TemporaryFileWrapper.writable";
    rf.short_name = "writable";
    rf.receiver_type = "tempfile._TemporaryFileWrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile._TemporaryFileWrapper.write";
    rf.short_name = "write";
    rf.receiver_type = "tempfile._TemporaryFileWrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile._TemporaryFileWrapper.writelines";
    rf.short_name = "writelines";
    rf.receiver_type = "tempfile._TemporaryFileWrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile._TemporaryFileWrapper.closed";
    rf.short_name = "closed";
    rf.receiver_type = "tempfile._TemporaryFileWrapper";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_805[] = { "encoding", "newlines", "__init__", "errors", "rollover", "__enter__", "__exit__", "close", "fileno", "flush", "isatty", "read1", "readinto", "readinto1", "detach", "read", "readline", "readlines", "seek", "tell", "truncate", "write", "writelines", "readable", "seekable", "writable", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "tempfile.SpooledTemporaryFile";
    rt.short_name = "SpooledTemporaryFile";
    rt.method_names = py_methods_805;
    static const char* py_bases_806[] = { "tempfile._SpooledTemporaryFileBase", NULL };
    rt.embedded_types = py_bases_806;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.encoding";
    rf.short_name = "encoding";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.newlines";
    rf.short_name = "newlines";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.errors";
    rf.short_name = "errors";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.rollover";
    rf.short_name = "rollover";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.close";
    rf.short_name = "close";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.fileno";
    rf.short_name = "fileno";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.flush";
    rf.short_name = "flush";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.isatty";
    rf.short_name = "isatty";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.read1";
    rf.short_name = "read1";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.readinto";
    rf.short_name = "readinto";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.readinto1";
    rf.short_name = "readinto1";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.detach";
    rf.short_name = "detach";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.read";
    rf.short_name = "read";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.readline";
    rf.short_name = "readline";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.readlines";
    rf.short_name = "readlines";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.seek";
    rf.short_name = "seek";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.tell";
    rf.short_name = "tell";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.truncate";
    rf.short_name = "truncate";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.write";
    rf.short_name = "write";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.writelines";
    rf.short_name = "writelines";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.readable";
    rf.short_name = "readable";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.seekable";
    rf.short_name = "seekable";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.SpooledTemporaryFile.writable";
    rf.short_name = "writable";
    rf.receiver_type = "tempfile.SpooledTemporaryFile";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_807[] = { "__init__", "cleanup", "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "tempfile.TemporaryDirectory";
    rt.short_name = "TemporaryDirectory";
    rt.method_names = py_methods_807;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.TemporaryDirectory.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "tempfile.TemporaryDirectory";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.TemporaryDirectory.cleanup";
    rf.short_name = "cleanup";
    rf.receiver_type = "tempfile.TemporaryDirectory";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.TemporaryDirectory.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "tempfile.TemporaryDirectory";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.TemporaryDirectory.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "tempfile.TemporaryDirectory";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.NamedTemporaryFile";
    rf.short_name = "NamedTemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.TemporaryFile";
    rf.short_name = "TemporaryFile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.mkstemp";
    rf.short_name = "mkstemp";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.mkdtemp";
    rf.short_name = "mkdtemp";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.mktemp";
    rf.short_name = "mktemp";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.gettempdirb";
    rf.short_name = "gettempdirb";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.gettempprefixb";
    rf.short_name = "gettempprefixb";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.gettempdir";
    rf.short_name = "gettempdir";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "tempfile.gettempprefix";
    rf.short_name = "gettempprefix";
    cbm_registry_add_func(reg, rf);

    /* ===== module: threading ===== */
    static const char* py_methods_808[] = { "ident", "__init__", "start", "run", "join", "native_id", "is_alive", "isDaemon", "setDaemon", "getName", "setName", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "threading.Thread";
    rt.short_name = "Thread";
    rt.method_names = py_methods_808;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Thread.ident";
    rf.short_name = "ident";
    rf.receiver_type = "threading.Thread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Thread.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "threading.Thread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Thread.start";
    rf.short_name = "start";
    rf.receiver_type = "threading.Thread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Thread.run";
    rf.short_name = "run";
    rf.receiver_type = "threading.Thread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Thread.join";
    rf.short_name = "join";
    rf.receiver_type = "threading.Thread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Thread.native_id";
    rf.short_name = "native_id";
    rf.receiver_type = "threading.Thread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Thread.is_alive";
    rf.short_name = "is_alive";
    rf.receiver_type = "threading.Thread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Thread.isDaemon";
    rf.short_name = "isDaemon";
    rf.receiver_type = "threading.Thread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Thread.setDaemon";
    rf.short_name = "setDaemon";
    rf.receiver_type = "threading.Thread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Thread.getName";
    rf.short_name = "getName";
    rf.receiver_type = "threading.Thread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Thread.setName";
    rf.short_name = "setName";
    rf.receiver_type = "threading.Thread";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_809[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "threading._DummyThread";
    rt.short_name = "_DummyThread";
    rt.method_names = py_methods_809;
    static const char* py_bases_810[] = { "threading.Thread", NULL };
    rt.embedded_types = py_bases_810;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading._DummyThread.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "threading._DummyThread";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_811[] = { "acquire", "release", "__exit__", "locked", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "threading._RLock";
    rt.short_name = "_RLock";
    rt.method_names = py_methods_811;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading._RLock.acquire";
    rf.short_name = "acquire";
    rf.receiver_type = "threading._RLock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading._RLock.release";
    rf.short_name = "release";
    rf.receiver_type = "threading._RLock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading._RLock.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "threading._RLock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading._RLock.locked";
    rf.short_name = "locked";
    rf.receiver_type = "threading._RLock";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_812[] = { "__init__", "__enter__", "__exit__", "acquire", "release", "locked", "wait", "wait_for", "notify", "notify_all", "notifyAll", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "threading.Condition";
    rt.short_name = "Condition";
    rt.method_names = py_methods_812;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Condition.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "threading.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Condition.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "threading.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Condition.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "threading.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Condition.acquire";
    rf.short_name = "acquire";
    rf.receiver_type = "threading.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Condition.release";
    rf.short_name = "release";
    rf.receiver_type = "threading.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Condition.locked";
    rf.short_name = "locked";
    rf.receiver_type = "threading.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Condition.wait";
    rf.short_name = "wait";
    rf.receiver_type = "threading.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Condition.wait_for";
    rf.short_name = "wait_for";
    rf.receiver_type = "threading.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Condition.notify";
    rf.short_name = "notify";
    rf.receiver_type = "threading.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Condition.notify_all";
    rf.short_name = "notify_all";
    rf.receiver_type = "threading.Condition";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Condition.notifyAll";
    rf.short_name = "notifyAll";
    rf.receiver_type = "threading.Condition";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_813[] = { "__init__", "__exit__", "acquire", "__enter__", "release", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "threading.Semaphore";
    rt.short_name = "Semaphore";
    rt.method_names = py_methods_813;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Semaphore.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "threading.Semaphore";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Semaphore.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "threading.Semaphore";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Semaphore.acquire";
    rf.short_name = "acquire";
    rf.receiver_type = "threading.Semaphore";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Semaphore.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "threading.Semaphore";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Semaphore.release";
    rf.short_name = "release";
    rf.receiver_type = "threading.Semaphore";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "threading.BoundedSemaphore";
    rt.short_name = "BoundedSemaphore";
    static const char* py_bases_814[] = { "threading.Semaphore", NULL };
    rt.embedded_types = py_bases_814;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_815[] = { "is_set", "isSet", "set", "clear", "wait", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "threading.Event";
    rt.short_name = "Event";
    rt.method_names = py_methods_815;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Event.is_set";
    rf.short_name = "is_set";
    rf.receiver_type = "threading.Event";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Event.isSet";
    rf.short_name = "isSet";
    rf.receiver_type = "threading.Event";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Event.set";
    rf.short_name = "set";
    rf.receiver_type = "threading.Event";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Event.clear";
    rf.short_name = "clear";
    rf.receiver_type = "threading.Event";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Event.wait";
    rf.short_name = "wait";
    rf.receiver_type = "threading.Event";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_816[] = { "__init__", "cancel", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "threading.Timer";
    rt.short_name = "Timer";
    rt.method_names = py_methods_816;
    static const char* py_bases_817[] = { "threading.Thread", NULL };
    rt.embedded_types = py_bases_817;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Timer.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "threading.Timer";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Timer.cancel";
    rf.short_name = "cancel";
    rf.receiver_type = "threading.Timer";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_818[] = { "parties", "n_waiting", "broken", "__init__", "wait", "reset", "abort", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "threading.Barrier";
    rt.short_name = "Barrier";
    rt.method_names = py_methods_818;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Barrier.parties";
    rf.short_name = "parties";
    rf.receiver_type = "threading.Barrier";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Barrier.n_waiting";
    rf.short_name = "n_waiting";
    rf.receiver_type = "threading.Barrier";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Barrier.broken";
    rf.short_name = "broken";
    rf.receiver_type = "threading.Barrier";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Barrier.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "threading.Barrier";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Barrier.wait";
    rf.short_name = "wait";
    rf.receiver_type = "threading.Barrier";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Barrier.reset";
    rf.short_name = "reset";
    rf.receiver_type = "threading.Barrier";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.Barrier.abort";
    rf.short_name = "abort";
    rf.receiver_type = "threading.Barrier";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "threading.BrokenBarrierError";
    rt.short_name = "BrokenBarrierError";
    static const char* py_bases_819[] = { "threading.RuntimeError", NULL };
    rt.embedded_types = py_bases_819;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.active_count";
    rf.short_name = "active_count";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.activeCount";
    rf.short_name = "activeCount";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.current_thread";
    rf.short_name = "current_thread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.currentThread";
    rf.short_name = "currentThread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.get_ident";
    rf.short_name = "get_ident";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.enumerate";
    rf.short_name = "enumerate";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.main_thread";
    rf.short_name = "main_thread";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.settrace";
    rf.short_name = "settrace";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.setprofile";
    rf.short_name = "setprofile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.setprofile_all_threads";
    rf.short_name = "setprofile_all_threads";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.settrace_all_threads";
    rf.short_name = "settrace_all_threads";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.gettrace";
    rf.short_name = "gettrace";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.getprofile";
    rf.short_name = "getprofile";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "threading.stack_size";
    rf.short_name = "stack_size";
    cbm_registry_add_func(reg, rf);

    /* ===== module: time ===== */
    static const char* py_methods_820[] = { "tm_year", "tm_mon", "tm_mday", "tm_hour", "tm_min", "tm_sec", "tm_wday", "tm_yday", "tm_isdst", "tm_zone", "tm_gmtoff", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "time.struct_time";
    rt.short_name = "struct_time";
    rt.method_names = py_methods_820;
    static const char* py_bases_821[] = { "time._TimeTuple", NULL };
    rt.embedded_types = py_bases_821;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.struct_time.tm_year";
    rf.short_name = "tm_year";
    rf.receiver_type = "time.struct_time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.struct_time.tm_mon";
    rf.short_name = "tm_mon";
    rf.receiver_type = "time.struct_time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.struct_time.tm_mday";
    rf.short_name = "tm_mday";
    rf.receiver_type = "time.struct_time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.struct_time.tm_hour";
    rf.short_name = "tm_hour";
    rf.receiver_type = "time.struct_time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.struct_time.tm_min";
    rf.short_name = "tm_min";
    rf.receiver_type = "time.struct_time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.struct_time.tm_sec";
    rf.short_name = "tm_sec";
    rf.receiver_type = "time.struct_time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.struct_time.tm_wday";
    rf.short_name = "tm_wday";
    rf.receiver_type = "time.struct_time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.struct_time.tm_yday";
    rf.short_name = "tm_yday";
    rf.receiver_type = "time.struct_time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.struct_time.tm_isdst";
    rf.short_name = "tm_isdst";
    rf.receiver_type = "time.struct_time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.struct_time.tm_zone";
    rf.short_name = "tm_zone";
    rf.receiver_type = "time.struct_time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.struct_time.tm_gmtoff";
    rf.short_name = "tm_gmtoff";
    rf.receiver_type = "time.struct_time";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "time._ClockInfo";
    rt.short_name = "_ClockInfo";
    static const char* py_bases_822[] = { "time.Protocol", NULL };
    rt.embedded_types = py_bases_822;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.asctime";
    rf.short_name = "asctime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.ctime";
    rf.short_name = "ctime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.gmtime";
    rf.short_name = "gmtime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.localtime";
    rf.short_name = "localtime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.mktime";
    rf.short_name = "mktime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.sleep";
    rf.short_name = "sleep";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.strftime";
    rf.short_name = "strftime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.strptime";
    rf.short_name = "strptime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.time";
    rf.short_name = "time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.tzset";
    rf.short_name = "tzset";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.get_clock_info";
    rf.short_name = "get_clock_info";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.monotonic";
    rf.short_name = "monotonic";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.perf_counter";
    rf.short_name = "perf_counter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.process_time";
    rf.short_name = "process_time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.clock_getres";
    rf.short_name = "clock_getres";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.clock_gettime";
    rf.short_name = "clock_gettime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.clock_settime";
    rf.short_name = "clock_settime";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.clock_gettime_ns";
    rf.short_name = "clock_gettime_ns";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.clock_settime_ns";
    rf.short_name = "clock_settime_ns";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.pthread_getcpuclockid";
    rf.short_name = "pthread_getcpuclockid";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.monotonic_ns";
    rf.short_name = "monotonic_ns";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.perf_counter_ns";
    rf.short_name = "perf_counter_ns";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.process_time_ns";
    rf.short_name = "process_time_ns";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.time_ns";
    rf.short_name = "time_ns";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.thread_time";
    rf.short_name = "thread_time";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.thread_time_ns";
    rf.short_name = "thread_time_ns";
    cbm_registry_add_func(reg, rf);

    /* ===== module: typing ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.Any";
    rt.short_name = "Any";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing._Final";
    rt.short_name = "_Final";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_823[] = { "__infer_variance__", "__default__", "__new__", "__typing_subst__", "__typing_prepare_subst__", "has_default", "evaluate_bound", "evaluate_constraints", "evaluate_default", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.TypeVar";
    rt.short_name = "TypeVar";
    rt.method_names = py_methods_823;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TypeVar.__infer_variance__";
    rf.short_name = "__infer_variance__";
    rf.receiver_type = "typing.TypeVar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TypeVar.__default__";
    rf.short_name = "__default__";
    rf.receiver_type = "typing.TypeVar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TypeVar.__new__";
    rf.short_name = "__new__";
    rf.receiver_type = "typing.TypeVar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TypeVar.__typing_subst__";
    rf.short_name = "__typing_subst__";
    rf.receiver_type = "typing.TypeVar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TypeVar.__typing_prepare_subst__";
    rf.short_name = "__typing_prepare_subst__";
    rf.receiver_type = "typing.TypeVar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TypeVar.has_default";
    rf.short_name = "has_default";
    rf.receiver_type = "typing.TypeVar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TypeVar.evaluate_bound";
    rf.short_name = "evaluate_bound";
    rf.receiver_type = "typing.TypeVar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TypeVar.evaluate_constraints";
    rf.short_name = "evaluate_constraints";
    rf.receiver_type = "typing.TypeVar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TypeVar.evaluate_default";
    rf.short_name = "evaluate_default";
    rf.receiver_type = "typing.TypeVar";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing._SpecialForm";
    rt.short_name = "_SpecialForm";
    static const char* py_bases_824[] = { "typing._Final", NULL };
    rt.embedded_types = py_bases_824;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_825[] = { "__bound__", "__covariant__", "__contravariant__", "__infer_variance__", "__default__", "has_default", "__new__", "evaluate_default", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.TypeVarTuple";
    rt.short_name = "TypeVarTuple";
    rt.method_names = py_methods_825;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TypeVarTuple.__bound__";
    rf.short_name = "__bound__";
    rf.receiver_type = "typing.TypeVarTuple";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TypeVarTuple.__covariant__";
    rf.short_name = "__covariant__";
    rf.receiver_type = "typing.TypeVarTuple";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TypeVarTuple.__contravariant__";
    rf.short_name = "__contravariant__";
    rf.receiver_type = "typing.TypeVarTuple";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TypeVarTuple.__infer_variance__";
    rf.short_name = "__infer_variance__";
    rf.receiver_type = "typing.TypeVarTuple";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TypeVarTuple.__default__";
    rf.short_name = "__default__";
    rf.receiver_type = "typing.TypeVarTuple";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TypeVarTuple.has_default";
    rf.short_name = "has_default";
    rf.receiver_type = "typing.TypeVarTuple";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TypeVarTuple.__new__";
    rf.short_name = "__new__";
    rf.receiver_type = "typing.TypeVarTuple";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TypeVarTuple.evaluate_default";
    rf.short_name = "evaluate_default";
    rf.receiver_type = "typing.TypeVarTuple";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_826[] = { "__new__", "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.ParamSpecArgs";
    rt.short_name = "ParamSpecArgs";
    rt.method_names = py_methods_826;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.ParamSpecArgs.__new__";
    rf.short_name = "__new__";
    rf.receiver_type = "typing.ParamSpecArgs";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.ParamSpecArgs.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "typing.ParamSpecArgs";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_827[] = { "__new__", "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.ParamSpecKwargs";
    rt.short_name = "ParamSpecKwargs";
    rt.method_names = py_methods_827;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.ParamSpecKwargs.__new__";
    rf.short_name = "__new__";
    rf.receiver_type = "typing.ParamSpecKwargs";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.ParamSpecKwargs.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "typing.ParamSpecKwargs";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_828[] = { "__infer_variance__", "__default__", "__new__", "args", "kwargs", "__typing_subst__", "__typing_prepare_subst__", "has_default", "evaluate_default", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.ParamSpec";
    rt.short_name = "ParamSpec";
    rt.method_names = py_methods_828;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.ParamSpec.__infer_variance__";
    rf.short_name = "__infer_variance__";
    rf.receiver_type = "typing.ParamSpec";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.ParamSpec.__default__";
    rf.short_name = "__default__";
    rf.receiver_type = "typing.ParamSpec";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.ParamSpec.__new__";
    rf.short_name = "__new__";
    rf.receiver_type = "typing.ParamSpec";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.ParamSpec.args";
    rf.short_name = "args";
    rf.receiver_type = "typing.ParamSpec";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.ParamSpec.kwargs";
    rf.short_name = "kwargs";
    rf.receiver_type = "typing.ParamSpec";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.ParamSpec.__typing_subst__";
    rf.short_name = "__typing_subst__";
    rf.receiver_type = "typing.ParamSpec";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.ParamSpec.__typing_prepare_subst__";
    rf.short_name = "__typing_prepare_subst__";
    rf.receiver_type = "typing.ParamSpec";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.ParamSpec.has_default";
    rf.short_name = "has_default";
    rf.receiver_type = "typing.ParamSpec";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.ParamSpec.evaluate_default";
    rf.short_name = "evaluate_default";
    rf.receiver_type = "typing.ParamSpec";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_829[] = { "__init__", "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.NewType";
    rt.short_name = "NewType";
    rt.method_names = py_methods_829;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.NewType.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "typing.NewType";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.NewType.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "typing.NewType";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing._Alias";
    rt.short_name = "_Alias";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing._NoExtraItemsType";
    rt.short_name = "_NoExtraItemsType";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing._Generic";
    rt.short_name = "_Generic";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_830[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing._ProtocolMeta";
    rt.short_name = "_ProtocolMeta";
    rt.method_names = py_methods_830;
    static const char* py_bases_831[] = { "typing.ABCMeta", NULL };
    rt.embedded_types = py_bases_831;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing._ProtocolMeta.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "typing._ProtocolMeta";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.SupportsInt";
    rt.short_name = "SupportsInt";
    static const char* py_bases_832[] = { "typing.Protocol", NULL };
    rt.embedded_types = py_bases_832;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.SupportsFloat";
    rt.short_name = "SupportsFloat";
    static const char* py_bases_833[] = { "typing.Protocol", NULL };
    rt.embedded_types = py_bases_833;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.SupportsComplex";
    rt.short_name = "SupportsComplex";
    static const char* py_bases_834[] = { "typing.Protocol", NULL };
    rt.embedded_types = py_bases_834;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.SupportsBytes";
    rt.short_name = "SupportsBytes";
    static const char* py_bases_835[] = { "typing.Protocol", NULL };
    rt.embedded_types = py_bases_835;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.SupportsIndex";
    rt.short_name = "SupportsIndex";
    static const char* py_bases_836[] = { "typing.Protocol", NULL };
    rt.embedded_types = py_bases_836;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.SupportsAbs";
    rt.short_name = "SupportsAbs";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.SupportsRound";
    rt.short_name = "SupportsRound";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.Sized";
    rt.short_name = "Sized";
    static const char* py_bases_837[] = { "typing.Protocol", NULL };
    rt.embedded_types = py_bases_837;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.Hashable";
    rt.short_name = "Hashable";
    static const char* py_bases_838[] = { "typing.Protocol", NULL };
    rt.embedded_types = py_bases_838;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.Iterable";
    rt.short_name = "Iterable";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.Iterator";
    rt.short_name = "Iterator";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.Reversible";
    rt.short_name = "Reversible";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_839[] = { "send", "throw", "close", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.Generator";
    rt.short_name = "Generator";
    rt.method_names = py_methods_839;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.Generator.send";
    rf.short_name = "send";
    rf.receiver_type = "typing.Generator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.Generator.throw";
    rf.short_name = "throw";
    rf.receiver_type = "typing.Generator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.Generator.close";
    rf.short_name = "close";
    rf.receiver_type = "typing.Generator";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.ContextManager";
    rt.short_name = "ContextManager";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.AsyncContextManager";
    rt.short_name = "AsyncContextManager";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.Awaitable";
    rt.short_name = "Awaitable";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_840[] = { "send", "throw", "close", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.Coroutine";
    rt.short_name = "Coroutine";
    rt.method_names = py_methods_840;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.Coroutine.send";
    rf.short_name = "send";
    rf.receiver_type = "typing.Coroutine";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.Coroutine.throw";
    rf.short_name = "throw";
    rf.receiver_type = "typing.Coroutine";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.Coroutine.close";
    rf.short_name = "close";
    rf.receiver_type = "typing.Coroutine";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.AwaitableGenerator";
    rt.short_name = "AwaitableGenerator";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.AsyncIterable";
    rt.short_name = "AsyncIterable";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.AsyncIterator";
    rt.short_name = "AsyncIterator";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_841[] = { "asend", "athrow", "aclose", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.AsyncGenerator";
    rt.short_name = "AsyncGenerator";
    rt.method_names = py_methods_841;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.AsyncGenerator.asend";
    rf.short_name = "asend";
    rf.receiver_type = "typing.AsyncGenerator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.AsyncGenerator.athrow";
    rf.short_name = "athrow";
    rf.receiver_type = "typing.AsyncGenerator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.AsyncGenerator.aclose";
    rf.short_name = "aclose";
    rf.receiver_type = "typing.AsyncGenerator";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.Container";
    rt.short_name = "Container";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.Collection";
    rt.short_name = "Collection";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_842[] = { "index", "count", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.Sequence";
    rt.short_name = "Sequence";
    rt.method_names = py_methods_842;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.Sequence.index";
    rf.short_name = "index";
    rf.receiver_type = "typing.Sequence";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.Sequence.count";
    rf.short_name = "count";
    rf.receiver_type = "typing.Sequence";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_843[] = { "insert", "append", "clear", "extend", "reverse", "pop", "remove", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.MutableSequence";
    rt.short_name = "MutableSequence";
    rt.method_names = py_methods_843;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.MutableSequence.insert";
    rf.short_name = "insert";
    rf.receiver_type = "typing.MutableSequence";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.MutableSequence.append";
    rf.short_name = "append";
    rf.receiver_type = "typing.MutableSequence";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.MutableSequence.clear";
    rf.short_name = "clear";
    rf.receiver_type = "typing.MutableSequence";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.MutableSequence.extend";
    rf.short_name = "extend";
    rf.receiver_type = "typing.MutableSequence";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.MutableSequence.reverse";
    rf.short_name = "reverse";
    rf.receiver_type = "typing.MutableSequence";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.MutableSequence.pop";
    rf.short_name = "pop";
    rf.receiver_type = "typing.MutableSequence";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.MutableSequence.remove";
    rf.short_name = "remove";
    rf.receiver_type = "typing.MutableSequence";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_844[] = { "isdisjoint", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.AbstractSet";
    rt.short_name = "AbstractSet";
    rt.method_names = py_methods_844;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.AbstractSet.isdisjoint";
    rf.short_name = "isdisjoint";
    rf.receiver_type = "typing.AbstractSet";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_845[] = { "add", "discard", "clear", "pop", "remove", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.MutableSet";
    rt.short_name = "MutableSet";
    rt.method_names = py_methods_845;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.MutableSet.add";
    rf.short_name = "add";
    rf.receiver_type = "typing.MutableSet";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.MutableSet.discard";
    rf.short_name = "discard";
    rf.receiver_type = "typing.MutableSet";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.MutableSet.clear";
    rf.short_name = "clear";
    rf.receiver_type = "typing.MutableSet";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.MutableSet.pop";
    rf.short_name = "pop";
    rf.receiver_type = "typing.MutableSet";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.MutableSet.remove";
    rf.short_name = "remove";
    rf.receiver_type = "typing.MutableSet";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_846[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.MappingView";
    rt.short_name = "MappingView";
    rt.method_names = py_methods_846;
    static const char* py_bases_847[] = { "typing.Sized", NULL };
    rt.embedded_types = py_bases_847;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.MappingView.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "typing.MappingView";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_848[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.ItemsView";
    rt.short_name = "ItemsView";
    rt.method_names = py_methods_848;
    static const char* py_bases_849[] = { "typing.MappingView", NULL };
    rt.embedded_types = py_bases_849;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.ItemsView.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "typing.ItemsView";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_850[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.KeysView";
    rt.short_name = "KeysView";
    rt.method_names = py_methods_850;
    static const char* py_bases_851[] = { "typing.MappingView", NULL };
    rt.embedded_types = py_bases_851;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.KeysView.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "typing.KeysView";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_852[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.ValuesView";
    rt.short_name = "ValuesView";
    rt.method_names = py_methods_852;
    static const char* py_bases_853[] = { "typing.MappingView", NULL };
    rt.embedded_types = py_bases_853;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.ValuesView.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "typing.ValuesView";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_854[] = { "get", "items", "keys", "values", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.Mapping";
    rt.short_name = "Mapping";
    rt.method_names = py_methods_854;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.Mapping.get";
    rf.short_name = "get";
    rf.receiver_type = "typing.Mapping";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.Mapping.items";
    rf.short_name = "items";
    rf.receiver_type = "typing.Mapping";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.Mapping.keys";
    rf.short_name = "keys";
    rf.receiver_type = "typing.Mapping";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.Mapping.values";
    rf.short_name = "values";
    rf.receiver_type = "typing.Mapping";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_855[] = { "clear", "pop", "popitem", "setdefault", "update", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.MutableMapping";
    rt.short_name = "MutableMapping";
    rt.method_names = py_methods_855;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.MutableMapping.clear";
    rf.short_name = "clear";
    rf.receiver_type = "typing.MutableMapping";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.MutableMapping.pop";
    rf.short_name = "pop";
    rf.receiver_type = "typing.MutableMapping";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.MutableMapping.popitem";
    rf.short_name = "popitem";
    rf.receiver_type = "typing.MutableMapping";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.MutableMapping.setdefault";
    rf.short_name = "setdefault";
    rf.receiver_type = "typing.MutableMapping";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.MutableMapping.update";
    rf.short_name = "update";
    rf.receiver_type = "typing.MutableMapping";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_856[] = { "mode", "name", "close", "closed", "fileno", "flush", "isatty", "read", "readable", "readline", "readlines", "seek", "seekable", "tell", "truncate", "writable", "write", "writelines", "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.IO";
    rt.short_name = "IO";
    rt.method_names = py_methods_856;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.IO.mode";
    rf.short_name = "mode";
    rf.receiver_type = "typing.IO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.IO.name";
    rf.short_name = "name";
    rf.receiver_type = "typing.IO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.IO.close";
    rf.short_name = "close";
    rf.receiver_type = "typing.IO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.IO.closed";
    rf.short_name = "closed";
    rf.receiver_type = "typing.IO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.IO.fileno";
    rf.short_name = "fileno";
    rf.receiver_type = "typing.IO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.IO.flush";
    rf.short_name = "flush";
    rf.receiver_type = "typing.IO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.IO.isatty";
    rf.short_name = "isatty";
    rf.receiver_type = "typing.IO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.IO.read";
    rf.short_name = "read";
    rf.receiver_type = "typing.IO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.IO.readable";
    rf.short_name = "readable";
    rf.receiver_type = "typing.IO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.IO.readline";
    rf.short_name = "readline";
    rf.receiver_type = "typing.IO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.IO.readlines";
    rf.short_name = "readlines";
    rf.receiver_type = "typing.IO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.IO.seek";
    rf.short_name = "seek";
    rf.receiver_type = "typing.IO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.IO.seekable";
    rf.short_name = "seekable";
    rf.receiver_type = "typing.IO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.IO.tell";
    rf.short_name = "tell";
    rf.receiver_type = "typing.IO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.IO.truncate";
    rf.short_name = "truncate";
    rf.receiver_type = "typing.IO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.IO.writable";
    rf.short_name = "writable";
    rf.receiver_type = "typing.IO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.IO.write";
    rf.short_name = "write";
    rf.receiver_type = "typing.IO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.IO.writelines";
    rf.short_name = "writelines";
    rf.receiver_type = "typing.IO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.IO.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "typing.IO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.IO.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "typing.IO";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_857[] = { "__enter__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.BinaryIO";
    rt.short_name = "BinaryIO";
    rt.method_names = py_methods_857;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.BinaryIO.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "typing.BinaryIO";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_858[] = { "buffer", "encoding", "errors", "line_buffering", "newlines", "__enter__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.TextIO";
    rt.short_name = "TextIO";
    rt.method_names = py_methods_858;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TextIO.buffer";
    rf.short_name = "buffer";
    rf.receiver_type = "typing.TextIO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TextIO.encoding";
    rf.short_name = "encoding";
    rf.receiver_type = "typing.TextIO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TextIO.errors";
    rf.short_name = "errors";
    rf.receiver_type = "typing.TextIO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TextIO.line_buffering";
    rf.short_name = "line_buffering";
    rf.receiver_type = "typing.TextIO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TextIO.newlines";
    rf.short_name = "newlines";
    rf.receiver_type = "typing.TextIO";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TextIO.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "typing.TextIO";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_859[] = { "__init__", "__replace__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.NamedTuple";
    rt.short_name = "NamedTuple";
    rt.method_names = py_methods_859;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.NamedTuple.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "typing.NamedTuple";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.NamedTuple.__replace__";
    rf.short_name = "__replace__";
    rf.receiver_type = "typing.NamedTuple";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_860[] = { "copy", "setdefault", "pop", "update", "items", "keys", "values", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing._TypedDict";
    rt.short_name = "_TypedDict";
    rt.method_names = py_methods_860;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing._TypedDict.copy";
    rf.short_name = "copy";
    rf.receiver_type = "typing._TypedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing._TypedDict.setdefault";
    rf.short_name = "setdefault";
    rf.receiver_type = "typing._TypedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing._TypedDict.pop";
    rf.short_name = "pop";
    rf.receiver_type = "typing._TypedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing._TypedDict.update";
    rf.short_name = "update";
    rf.receiver_type = "typing._TypedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing._TypedDict.items";
    rf.short_name = "items";
    rf.receiver_type = "typing._TypedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing._TypedDict.keys";
    rf.short_name = "keys";
    rf.receiver_type = "typing._TypedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing._TypedDict.values";
    rf.short_name = "values";
    rf.receiver_type = "typing._TypedDict";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_861[] = { "__init__", "_evaluate", "__or__", "__ror__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.ForwardRef";
    rt.short_name = "ForwardRef";
    rt.method_names = py_methods_861;
    static const char* py_bases_862[] = { "typing._Final", NULL };
    rt.embedded_types = py_bases_862;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.ForwardRef.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "typing.ForwardRef";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.ForwardRef._evaluate";
    rf.short_name = "_evaluate";
    rf.receiver_type = "typing.ForwardRef";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.ForwardRef.__or__";
    rf.short_name = "__or__";
    rf.receiver_type = "typing.ForwardRef";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.ForwardRef.__ror__";
    rf.short_name = "__ror__";
    rf.receiver_type = "typing.ForwardRef";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_863[] = { "__qualname__", "__iter__", "evaluate_value", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing.TypeAliasType";
    rt.short_name = "TypeAliasType";
    rt.method_names = py_methods_863;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TypeAliasType.__qualname__";
    rf.short_name = "__qualname__";
    rf.receiver_type = "typing.TypeAliasType";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TypeAliasType.__iter__";
    rf.short_name = "__iter__";
    rf.receiver_type = "typing.TypeAliasType";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.TypeAliasType.evaluate_value";
    rf.short_name = "evaluate_value";
    rf.receiver_type = "typing.TypeAliasType";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing._NoDefaultType";
    rt.short_name = "_NoDefaultType";
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.final";
    rf.short_name = "final";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.overload";
    rf.short_name = "overload";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.no_type_check";
    rf.short_name = "no_type_check";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.no_type_check_decorator";
    rf.short_name = "no_type_check_decorator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.disjoint_base";
    rf.short_name = "disjoint_base";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.type_check_only";
    rf.short_name = "type_check_only";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.runtime_checkable";
    rf.short_name = "runtime_checkable";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.get_type_hints";
    rf.short_name = "get_type_hints";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.get_args";
    rf.short_name = "get_args";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.get_origin";
    rf.short_name = "get_origin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.cast";
    rf.short_name = "cast";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.reveal_type";
    rf.short_name = "reveal_type";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.assert_never";
    rf.short_name = "assert_never";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.assert_type";
    rf.short_name = "assert_type";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.clear_overloads";
    rf.short_name = "clear_overloads";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.get_overloads";
    rf.short_name = "get_overloads";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.dataclass_transform";
    rf.short_name = "dataclass_transform";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.evaluate_forward_ref";
    rf.short_name = "evaluate_forward_ref";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.is_typeddict";
    rf.short_name = "is_typeddict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.override";
    rf.short_name = "override";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.is_protocol";
    rf.short_name = "is_protocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing.get_protocol_members";
    rf.short_name = "get_protocol_members";
    cbm_registry_add_func(reg, rf);

    /* ===== module: typing_extensions ===== */
    static const char* py_methods_864[] = { "copy", "setdefault", "pop", "update", "items", "keys", "values", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions._TypedDict";
    rt.short_name = "_TypedDict";
    rt.method_names = py_methods_864;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions._TypedDict.copy";
    rf.short_name = "copy";
    rf.receiver_type = "typing_extensions._TypedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions._TypedDict.setdefault";
    rf.short_name = "setdefault";
    rf.receiver_type = "typing_extensions._TypedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions._TypedDict.pop";
    rf.short_name = "pop";
    rf.receiver_type = "typing_extensions._TypedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions._TypedDict.update";
    rf.short_name = "update";
    rf.receiver_type = "typing_extensions._TypedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions._TypedDict.items";
    rf.short_name = "items";
    rf.receiver_type = "typing_extensions._TypedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions._TypedDict.keys";
    rf.short_name = "keys";
    rf.receiver_type = "typing_extensions._TypedDict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions._TypedDict.values";
    rf.short_name = "values";
    rf.receiver_type = "typing_extensions._TypedDict";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_865[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.NamedTuple";
    rt.short_name = "NamedTuple";
    rt.method_names = py_methods_865;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.NamedTuple.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "typing_extensions.NamedTuple";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_866[] = { "__init__", "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.NewType";
    rt.short_name = "NewType";
    rt.method_names = py_methods_866;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.NewType.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "typing_extensions.NewType";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.NewType.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "typing_extensions.NewType";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.Buffer";
    rt.short_name = "Buffer";
    static const char* py_bases_867[] = { "typing_extensions.Protocol", "abc.ABC", NULL };
    rt.embedded_types = py_bases_867;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.SupportsInt";
    rt.short_name = "SupportsInt";
    static const char* py_bases_868[] = { "typing_extensions.Protocol", NULL };
    rt.embedded_types = py_bases_868;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.SupportsFloat";
    rt.short_name = "SupportsFloat";
    static const char* py_bases_869[] = { "typing_extensions.Protocol", NULL };
    rt.embedded_types = py_bases_869;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.SupportsComplex";
    rt.short_name = "SupportsComplex";
    static const char* py_bases_870[] = { "typing_extensions.Protocol", NULL };
    rt.embedded_types = py_bases_870;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.SupportsBytes";
    rt.short_name = "SupportsBytes";
    static const char* py_bases_871[] = { "typing_extensions.Protocol", NULL };
    rt.embedded_types = py_bases_871;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.SupportsIndex";
    rt.short_name = "SupportsIndex";
    static const char* py_bases_872[] = { "typing_extensions.Protocol", NULL };
    rt.embedded_types = py_bases_872;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.SupportsAbs";
    rt.short_name = "SupportsAbs";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.SupportsRound";
    rt.short_name = "SupportsRound";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_873[] = { "read", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.Reader";
    rt.short_name = "Reader";
    rt.method_names = py_methods_873;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.Reader.read";
    rf.short_name = "read";
    rf.receiver_type = "typing_extensions.Reader";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_874[] = { "write", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.Writer";
    rt.short_name = "Writer";
    rt.method_names = py_methods_874;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.Writer.write";
    rf.short_name = "write";
    rf.receiver_type = "typing_extensions.Writer";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions._NoDefaultType";
    rt.short_name = "_NoDefaultType";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.CapsuleType";
    rt.short_name = "CapsuleType";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_875[] = { "__init__", "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.deprecated";
    rt.short_name = "deprecated";
    rt.method_names = py_methods_875;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.deprecated.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "typing_extensions.deprecated";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.deprecated.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "typing_extensions.deprecated";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_876[] = { "__init__", "has_default", "__typing_subst__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.TypeVar";
    rt.short_name = "TypeVar";
    rt.method_names = py_methods_876;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.TypeVar.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "typing_extensions.TypeVar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.TypeVar.has_default";
    rf.short_name = "has_default";
    rf.receiver_type = "typing_extensions.TypeVar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.TypeVar.__typing_subst__";
    rf.short_name = "__typing_subst__";
    rf.receiver_type = "typing_extensions.TypeVar";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_877[] = { "__init__", "args", "kwargs", "has_default", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.ParamSpec";
    rt.short_name = "ParamSpec";
    rt.method_names = py_methods_877;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.ParamSpec.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "typing_extensions.ParamSpec";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.ParamSpec.args";
    rf.short_name = "args";
    rf.receiver_type = "typing_extensions.ParamSpec";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.ParamSpec.kwargs";
    rf.short_name = "kwargs";
    rf.receiver_type = "typing_extensions.ParamSpec";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.ParamSpec.has_default";
    rf.short_name = "has_default";
    rf.receiver_type = "typing_extensions.ParamSpec";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_878[] = { "__init__", "has_default", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.TypeVarTuple";
    rt.short_name = "TypeVarTuple";
    rt.method_names = py_methods_878;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.TypeVarTuple.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "typing_extensions.TypeVarTuple";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.TypeVarTuple.has_default";
    rf.short_name = "has_default";
    rf.receiver_type = "typing_extensions.TypeVarTuple";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_879[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.TypeAliasType";
    rt.short_name = "TypeAliasType";
    rt.method_names = py_methods_879;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.TypeAliasType.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "typing_extensions.TypeAliasType";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_880[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.Doc";
    rt.short_name = "Doc";
    rt.method_names = py_methods_880;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.Doc.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "typing_extensions.Doc";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions._NoExtraItemsType";
    rt.short_name = "_NoExtraItemsType";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.Format";
    rt.short_name = "Format";
    static const char* py_bases_881[] = { "enum.IntEnum", NULL };
    rt.embedded_types = py_bases_881;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_882[] = { "__init__", "__or__", "__ror__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "typing_extensions.Sentinel";
    rt.short_name = "Sentinel";
    rt.method_names = py_methods_882;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.Sentinel.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "typing_extensions.Sentinel";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.Sentinel.__or__";
    rf.short_name = "__or__";
    rf.receiver_type = "typing_extensions.Sentinel";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.Sentinel.__ror__";
    rf.short_name = "__ror__";
    rf.receiver_type = "typing_extensions.Sentinel";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.no_type_check_decorator";
    rf.short_name = "no_type_check_decorator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.runtime_checkable";
    rf.short_name = "runtime_checkable";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.final";
    rf.short_name = "final";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.disjoint_base";
    rf.short_name = "disjoint_base";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.IntVar";
    rf.short_name = "IntVar";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.get_type_hints";
    rf.short_name = "get_type_hints";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.get_args";
    rf.short_name = "get_args";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.get_origin";
    rf.short_name = "get_origin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.reveal_type";
    rf.short_name = "reveal_type";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.assert_never";
    rf.short_name = "assert_never";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.assert_type";
    rf.short_name = "assert_type";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.clear_overloads";
    rf.short_name = "clear_overloads";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.get_overloads";
    rf.short_name = "get_overloads";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.dataclass_transform";
    rf.short_name = "dataclass_transform";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.override";
    rf.short_name = "override";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.get_original_bases";
    rf.short_name = "get_original_bases";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.is_protocol";
    rf.short_name = "is_protocol";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.get_protocol_members";
    rf.short_name = "get_protocol_members";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.get_annotations";
    rf.short_name = "get_annotations";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.evaluate_forward_ref";
    rf.short_name = "evaluate_forward_ref";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "typing_extensions.type_repr";
    rf.short_name = "type_repr";
    cbm_registry_add_func(reg, rf);

    /* ===== module: unittest ===== */
    static const char* py_methods_883[] = { "asyncSetUp", "asyncTearDown", "addAsyncCleanup", "enterAsyncContext", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.IsolatedAsyncioTestCase";
    rt.short_name = "IsolatedAsyncioTestCase";
    rt.method_names = py_methods_883;
    static const char* py_bases_884[] = { "unittest.async_case.TestCase", NULL };
    rt.embedded_types = py_bases_884;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.IsolatedAsyncioTestCase.asyncSetUp";
    rf.short_name = "asyncSetUp";
    rf.receiver_type = "unittest.IsolatedAsyncioTestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.IsolatedAsyncioTestCase.asyncTearDown";
    rf.short_name = "asyncTearDown";
    rf.receiver_type = "unittest.IsolatedAsyncioTestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.IsolatedAsyncioTestCase.addAsyncCleanup";
    rf.short_name = "addAsyncCleanup";
    rf.receiver_type = "unittest.IsolatedAsyncioTestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.IsolatedAsyncioTestCase.enterAsyncContext";
    rf.short_name = "enterAsyncContext";
    rf.receiver_type = "unittest.IsolatedAsyncioTestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.load_tests";
    rf.short_name = "load_tests";
    cbm_registry_add_func(reg, rf);

    /* ===== module: unittest._log ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest._log._LoggingWatcher";
    rt.short_name = "_LoggingWatcher";
    static const char* py_bases_885[] = { "unittest._log.NamedTuple", NULL };
    rt.embedded_types = py_bases_885;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_886[] = { "__init__", "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest._log._AssertLogsContext";
    rt.short_name = "_AssertLogsContext";
    rt.method_names = py_methods_886;
    static const char* py_bases_887[] = { "unittest._log._BaseTestCaseContext", NULL };
    rt.embedded_types = py_bases_887;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest._log._AssertLogsContext.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest._log._AssertLogsContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest._log._AssertLogsContext.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "unittest._log._AssertLogsContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest._log._AssertLogsContext.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "unittest._log._AssertLogsContext";
    cbm_registry_add_func(reg, rf);

    /* ===== module: unittest.async_case ===== */
    static const char* py_methods_888[] = { "asyncSetUp", "asyncTearDown", "addAsyncCleanup", "enterAsyncContext", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.async_case.IsolatedAsyncioTestCase";
    rt.short_name = "IsolatedAsyncioTestCase";
    rt.method_names = py_methods_888;
    static const char* py_bases_889[] = { "unittest.async_case.TestCase", NULL };
    rt.embedded_types = py_bases_889;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.async_case.IsolatedAsyncioTestCase.asyncSetUp";
    rf.short_name = "asyncSetUp";
    rf.receiver_type = "unittest.async_case.IsolatedAsyncioTestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.async_case.IsolatedAsyncioTestCase.asyncTearDown";
    rf.short_name = "asyncTearDown";
    rf.receiver_type = "unittest.async_case.IsolatedAsyncioTestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.async_case.IsolatedAsyncioTestCase.addAsyncCleanup";
    rf.short_name = "addAsyncCleanup";
    rf.receiver_type = "unittest.async_case.IsolatedAsyncioTestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.async_case.IsolatedAsyncioTestCase.enterAsyncContext";
    rf.short_name = "enterAsyncContext";
    rf.receiver_type = "unittest.async_case.IsolatedAsyncioTestCase";
    cbm_registry_add_func(reg, rf);

    /* ===== module: unittest.case ===== */
    static const char* py_methods_890[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.case._BaseTestCaseContext";
    rt.short_name = "_BaseTestCaseContext";
    rt.method_names = py_methods_890;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case._BaseTestCaseContext.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.case._BaseTestCaseContext";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_891[] = { "__init__", "handle", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.case._AssertRaisesBaseContext";
    rt.short_name = "_AssertRaisesBaseContext";
    rt.method_names = py_methods_891;
    static const char* py_bases_892[] = { "unittest.case._BaseTestCaseContext", NULL };
    rt.embedded_types = py_bases_892;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case._AssertRaisesBaseContext.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.case._AssertRaisesBaseContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case._AssertRaisesBaseContext.handle";
    rf.short_name = "handle";
    rf.receiver_type = "unittest.case._AssertRaisesBaseContext";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_893[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.case.SkipTest";
    rt.short_name = "SkipTest";
    rt.method_names = py_methods_893;
    static const char* py_bases_894[] = { "unittest.case.Exception", NULL };
    rt.embedded_types = py_bases_894;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.SkipTest.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.case.SkipTest";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.case._SupportsAbsAndDunderGE";
    rt.short_name = "_SupportsAbsAndDunderGE";
    static const char* py_bases_895[] = { "unittest.case.Protocol", NULL };
    rt.embedded_types = py_bases_895;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_896[] = { "__init__", "setUp", "tearDown", "setUpClass", "tearDownClass", "run", "__call__", "skipTest", "subTest", "debug", "_addSkip", "assertEqual", "assertNotEqual", "assertTrue", "assertFalse", "assertIs", "assertIsNot", "assertIsNone", "assertIsNotNone", "assertIn", "assertNotIn", "assertIsInstance", "assertNotIsInstance", "assertGreater", "assertGreaterEqual", "assertLess", "assertLessEqual", "assertRaises", "assertRaisesRegex", "assertWarns", "assertWarnsRegex", "assertLogs", "assertNoLogs", "assertAlmostEqual", "assertNotAlmostEqual", "assertRegex", "assertNotRegex", "assertCountEqual", "addTypeEqualityFunc", "assertMultiLineEqual", "assertSequenceEqual", "assertListEqual", "assertTupleEqual", "assertSetEqual", "assertDictEqual", "fail", "countTestCases", "defaultTestResult", "id", "shortDescription", "addCleanup", "enterContext", "doCleanups", "addClassCleanup", "doClassCleanups", "enterClassContext", "assertDictContainsSubset", "assertIsSubclass", "assertNotIsSubclass", "assertHasAttr", "assertNotHasAttr", "assertStartsWith", "assertNotStartsWith", "assertEndsWith", "assertNotEndsWith", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.case.TestCase";
    rt.short_name = "TestCase";
    rt.method_names = py_methods_896;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.setUp";
    rf.short_name = "setUp";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.tearDown";
    rf.short_name = "tearDown";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.setUpClass";
    rf.short_name = "setUpClass";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.tearDownClass";
    rf.short_name = "tearDownClass";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.run";
    rf.short_name = "run";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.skipTest";
    rf.short_name = "skipTest";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.subTest";
    rf.short_name = "subTest";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.debug";
    rf.short_name = "debug";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase._addSkip";
    rf.short_name = "_addSkip";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertEqual";
    rf.short_name = "assertEqual";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertNotEqual";
    rf.short_name = "assertNotEqual";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertTrue";
    rf.short_name = "assertTrue";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertFalse";
    rf.short_name = "assertFalse";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertIs";
    rf.short_name = "assertIs";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertIsNot";
    rf.short_name = "assertIsNot";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertIsNone";
    rf.short_name = "assertIsNone";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertIsNotNone";
    rf.short_name = "assertIsNotNone";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertIn";
    rf.short_name = "assertIn";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertNotIn";
    rf.short_name = "assertNotIn";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertIsInstance";
    rf.short_name = "assertIsInstance";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertNotIsInstance";
    rf.short_name = "assertNotIsInstance";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertGreater";
    rf.short_name = "assertGreater";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertGreaterEqual";
    rf.short_name = "assertGreaterEqual";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertLess";
    rf.short_name = "assertLess";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertLessEqual";
    rf.short_name = "assertLessEqual";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertRaises";
    rf.short_name = "assertRaises";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertRaisesRegex";
    rf.short_name = "assertRaisesRegex";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertWarns";
    rf.short_name = "assertWarns";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertWarnsRegex";
    rf.short_name = "assertWarnsRegex";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertLogs";
    rf.short_name = "assertLogs";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertNoLogs";
    rf.short_name = "assertNoLogs";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertAlmostEqual";
    rf.short_name = "assertAlmostEqual";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertNotAlmostEqual";
    rf.short_name = "assertNotAlmostEqual";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertRegex";
    rf.short_name = "assertRegex";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertNotRegex";
    rf.short_name = "assertNotRegex";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertCountEqual";
    rf.short_name = "assertCountEqual";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.addTypeEqualityFunc";
    rf.short_name = "addTypeEqualityFunc";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertMultiLineEqual";
    rf.short_name = "assertMultiLineEqual";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertSequenceEqual";
    rf.short_name = "assertSequenceEqual";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertListEqual";
    rf.short_name = "assertListEqual";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertTupleEqual";
    rf.short_name = "assertTupleEqual";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertSetEqual";
    rf.short_name = "assertSetEqual";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertDictEqual";
    rf.short_name = "assertDictEqual";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.fail";
    rf.short_name = "fail";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.countTestCases";
    rf.short_name = "countTestCases";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.defaultTestResult";
    rf.short_name = "defaultTestResult";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.id";
    rf.short_name = "id";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.shortDescription";
    rf.short_name = "shortDescription";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.addCleanup";
    rf.short_name = "addCleanup";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.enterContext";
    rf.short_name = "enterContext";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.doCleanups";
    rf.short_name = "doCleanups";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.addClassCleanup";
    rf.short_name = "addClassCleanup";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.doClassCleanups";
    rf.short_name = "doClassCleanups";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.enterClassContext";
    rf.short_name = "enterClassContext";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertDictContainsSubset";
    rf.short_name = "assertDictContainsSubset";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertIsSubclass";
    rf.short_name = "assertIsSubclass";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertNotIsSubclass";
    rf.short_name = "assertNotIsSubclass";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertHasAttr";
    rf.short_name = "assertHasAttr";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertNotHasAttr";
    rf.short_name = "assertNotHasAttr";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertStartsWith";
    rf.short_name = "assertStartsWith";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertNotStartsWith";
    rf.short_name = "assertNotStartsWith";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertEndsWith";
    rf.short_name = "assertEndsWith";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.TestCase.assertNotEndsWith";
    rf.short_name = "assertNotEndsWith";
    rf.receiver_type = "unittest.case.TestCase";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_897[] = { "__init__", "runTest", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.case.FunctionTestCase";
    rt.short_name = "FunctionTestCase";
    rt.method_names = py_methods_897;
    static const char* py_bases_898[] = { "unittest.case.TestCase", NULL };
    rt.embedded_types = py_bases_898;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.FunctionTestCase.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.case.FunctionTestCase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.FunctionTestCase.runTest";
    rf.short_name = "runTest";
    rf.receiver_type = "unittest.case.FunctionTestCase";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_899[] = { "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.case._AssertRaisesContext";
    rt.short_name = "_AssertRaisesContext";
    rt.method_names = py_methods_899;
    static const char* py_bases_900[] = { "unittest.case._AssertRaisesBaseContext", NULL };
    rt.embedded_types = py_bases_900;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case._AssertRaisesContext.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "unittest.case._AssertRaisesContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case._AssertRaisesContext.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "unittest.case._AssertRaisesContext";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_901[] = { "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.case._AssertWarnsContext";
    rt.short_name = "_AssertWarnsContext";
    rt.method_names = py_methods_901;
    static const char* py_bases_902[] = { "unittest.case._AssertRaisesBaseContext", NULL };
    rt.embedded_types = py_bases_902;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case._AssertWarnsContext.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "unittest.case._AssertWarnsContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case._AssertWarnsContext.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "unittest.case._AssertWarnsContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.addModuleCleanup";
    rf.short_name = "addModuleCleanup";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.doModuleCleanups";
    rf.short_name = "doModuleCleanups";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.enterModuleContext";
    rf.short_name = "enterModuleContext";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.expectedFailure";
    rf.short_name = "expectedFailure";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.skip";
    rf.short_name = "skip";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.skipIf";
    rf.short_name = "skipIf";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.case.skipUnless";
    rf.short_name = "skipUnless";
    cbm_registry_add_func(reg, rf);

    /* ===== module: unittest.loader ===== */
    static const char* py_methods_903[] = { "loadTestsFromTestCase", "loadTestsFromModule", "loadTestsFromName", "loadTestsFromNames", "getTestCaseNames", "discover", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.loader.TestLoader";
    rt.short_name = "TestLoader";
    rt.method_names = py_methods_903;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.loader.TestLoader.loadTestsFromTestCase";
    rf.short_name = "loadTestsFromTestCase";
    rf.receiver_type = "unittest.loader.TestLoader";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.loader.TestLoader.loadTestsFromModule";
    rf.short_name = "loadTestsFromModule";
    rf.receiver_type = "unittest.loader.TestLoader";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.loader.TestLoader.loadTestsFromName";
    rf.short_name = "loadTestsFromName";
    rf.receiver_type = "unittest.loader.TestLoader";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.loader.TestLoader.loadTestsFromNames";
    rf.short_name = "loadTestsFromNames";
    rf.receiver_type = "unittest.loader.TestLoader";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.loader.TestLoader.getTestCaseNames";
    rf.short_name = "getTestCaseNames";
    rf.receiver_type = "unittest.loader.TestLoader";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.loader.TestLoader.discover";
    rf.short_name = "discover";
    rf.receiver_type = "unittest.loader.TestLoader";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.loader.getTestCaseNames";
    rf.short_name = "getTestCaseNames";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.loader.makeSuite";
    rf.short_name = "makeSuite";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.loader.findTestCases";
    rf.short_name = "findTestCases";
    cbm_registry_add_func(reg, rf);

    /* ===== module: unittest.main ===== */
    static const char* py_methods_904[] = { "run", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.main._TestRunner";
    rt.short_name = "_TestRunner";
    rt.method_names = py_methods_904;
    static const char* py_bases_905[] = { "unittest.main.Protocol", NULL };
    rt.embedded_types = py_bases_905;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.main._TestRunner.run";
    rf.short_name = "run";
    rf.receiver_type = "unittest.main._TestRunner";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_906[] = { "__init__", "parseArgs", "createTests", "runTests", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.main.TestProgram";
    rt.short_name = "TestProgram";
    rt.method_names = py_methods_906;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.main.TestProgram.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.main.TestProgram";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.main.TestProgram.parseArgs";
    rf.short_name = "parseArgs";
    rf.receiver_type = "unittest.main.TestProgram";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.main.TestProgram.createTests";
    rf.short_name = "createTests";
    rf.receiver_type = "unittest.main.TestProgram";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.main.TestProgram.runTests";
    rf.short_name = "runTests";
    rf.receiver_type = "unittest.main.TestProgram";
    cbm_registry_add_func(reg, rf);

    /* ===== module: unittest.mock ===== */
    static const char* py_methods_907[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock._SentinelObject";
    rt.short_name = "_SentinelObject";
    rt.method_names = py_methods_907;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._SentinelObject.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.mock._SentinelObject";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock._Sentinel";
    rt.short_name = "_Sentinel";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_908[] = { "__init__", "__call__", "args", "kwargs", "call_list", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock._Call";
    rt.short_name = "_Call";
    rt.method_names = py_methods_908;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._Call.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.mock._Call";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._Call.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "unittest.mock._Call";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._Call.args";
    rf.short_name = "args";
    rf.receiver_type = "unittest.mock._Call";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._Call.kwargs";
    rf.short_name = "kwargs";
    rf.receiver_type = "unittest.mock._Call";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._Call.call_list";
    rf.short_name = "call_list";
    rf.receiver_type = "unittest.mock._Call";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_909[] = { "__init__", "__call__", "args", "kwargs", "call_list", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock._Call";
    rt.short_name = "_Call";
    rt.method_names = py_methods_909;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._Call.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.mock._Call";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._Call.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "unittest.mock._Call";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._Call.args";
    rf.short_name = "args";
    rf.receiver_type = "unittest.mock._Call";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._Call.kwargs";
    rf.short_name = "kwargs";
    rf.receiver_type = "unittest.mock._Call";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._Call.call_list";
    rf.short_name = "call_list";
    rf.receiver_type = "unittest.mock._Call";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock._CallList";
    rt.short_name = "_CallList";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_910[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock.Base";
    rt.short_name = "Base";
    rt.method_names = py_methods_910;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.Base.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.mock.Base";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_911[] = { "__new__", "__init__", "assert_called_with", "assert_not_called", "assert_called_once_with", "assert_called", "assert_called_once", "reset_mock", "assert_any_call", "assert_has_calls", "mock_add_spec", "attach_mock", "configure_mock", "_calls_repr", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock.NonCallableMock";
    rt.short_name = "NonCallableMock";
    rt.method_names = py_methods_911;
    static const char* py_bases_912[] = { "unittest.mock.Base", "unittest.mock.Any", NULL };
    rt.embedded_types = py_bases_912;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.NonCallableMock.__new__";
    rf.short_name = "__new__";
    rf.receiver_type = "unittest.mock.NonCallableMock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.NonCallableMock.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.mock.NonCallableMock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.NonCallableMock.assert_called_with";
    rf.short_name = "assert_called_with";
    rf.receiver_type = "unittest.mock.NonCallableMock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.NonCallableMock.assert_not_called";
    rf.short_name = "assert_not_called";
    rf.receiver_type = "unittest.mock.NonCallableMock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.NonCallableMock.assert_called_once_with";
    rf.short_name = "assert_called_once_with";
    rf.receiver_type = "unittest.mock.NonCallableMock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.NonCallableMock.assert_called";
    rf.short_name = "assert_called";
    rf.receiver_type = "unittest.mock.NonCallableMock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.NonCallableMock.assert_called_once";
    rf.short_name = "assert_called_once";
    rf.receiver_type = "unittest.mock.NonCallableMock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.NonCallableMock.reset_mock";
    rf.short_name = "reset_mock";
    rf.receiver_type = "unittest.mock.NonCallableMock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.NonCallableMock.assert_any_call";
    rf.short_name = "assert_any_call";
    rf.receiver_type = "unittest.mock.NonCallableMock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.NonCallableMock.assert_has_calls";
    rf.short_name = "assert_has_calls";
    rf.receiver_type = "unittest.mock.NonCallableMock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.NonCallableMock.mock_add_spec";
    rf.short_name = "mock_add_spec";
    rf.receiver_type = "unittest.mock.NonCallableMock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.NonCallableMock.attach_mock";
    rf.short_name = "attach_mock";
    rf.receiver_type = "unittest.mock.NonCallableMock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.NonCallableMock.configure_mock";
    rf.short_name = "configure_mock";
    rf.receiver_type = "unittest.mock.NonCallableMock";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.NonCallableMock._calls_repr";
    rf.short_name = "_calls_repr";
    rf.receiver_type = "unittest.mock.NonCallableMock";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_913[] = { "__init__", "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock.CallableMixin";
    rt.short_name = "CallableMixin";
    rt.method_names = py_methods_913;
    static const char* py_bases_914[] = { "unittest.mock.Base", NULL };
    rt.embedded_types = py_bases_914;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.CallableMixin.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.mock.CallableMixin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.CallableMixin.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "unittest.mock.CallableMixin";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock.Mock";
    rt.short_name = "Mock";
    static const char* py_bases_915[] = { "unittest.mock.CallableMixin", "unittest.mock.NonCallableMock", NULL };
    rt.embedded_types = py_bases_915;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_916[] = { "__init__", "copy", "__call__", "decoration_helper", "decorate_class", "decorate_callable", "decorate_async_callable", "get_original", "__enter__", "__exit__", "start", "stop", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock._patch";
    rt.short_name = "_patch";
    rt.method_names = py_methods_916;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patch.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.mock._patch";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patch.copy";
    rf.short_name = "copy";
    rf.receiver_type = "unittest.mock._patch";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patch.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "unittest.mock._patch";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patch.decoration_helper";
    rf.short_name = "decoration_helper";
    rf.receiver_type = "unittest.mock._patch";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patch.decorate_class";
    rf.short_name = "decorate_class";
    rf.receiver_type = "unittest.mock._patch";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patch.decorate_callable";
    rf.short_name = "decorate_callable";
    rf.receiver_type = "unittest.mock._patch";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patch.decorate_async_callable";
    rf.short_name = "decorate_async_callable";
    rf.receiver_type = "unittest.mock._patch";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patch.get_original";
    rf.short_name = "get_original";
    rf.receiver_type = "unittest.mock._patch";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patch.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "unittest.mock._patch";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patch.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "unittest.mock._patch";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patch.start";
    rf.short_name = "start";
    rf.receiver_type = "unittest.mock._patch";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patch.stop";
    rf.short_name = "stop";
    rf.receiver_type = "unittest.mock._patch";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_917[] = { "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock._patch_pass_arg";
    rt.short_name = "_patch_pass_arg";
    rt.method_names = py_methods_917;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patch_pass_arg.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "unittest.mock._patch_pass_arg";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_918[] = { "__init__", "__call__", "__enter__", "__exit__", "decorate_callable", "decorate_async_callable", "decorate_class", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock._patch_dict";
    rt.short_name = "_patch_dict";
    rt.method_names = py_methods_918;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patch_dict.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.mock._patch_dict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patch_dict.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "unittest.mock._patch_dict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patch_dict.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "unittest.mock._patch_dict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patch_dict.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "unittest.mock._patch_dict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patch_dict.decorate_callable";
    rf.short_name = "decorate_callable";
    rf.receiver_type = "unittest.mock._patch_dict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patch_dict.decorate_async_callable";
    rf.short_name = "decorate_async_callable";
    rf.receiver_type = "unittest.mock._patch_dict";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patch_dict.decorate_class";
    rf.short_name = "decorate_class";
    rf.receiver_type = "unittest.mock._patch_dict";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_919[] = { "__call__", "object", "multiple", "stopall", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock._patcher";
    rt.short_name = "_patcher";
    rt.method_names = py_methods_919;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patcher.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "unittest.mock._patcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patcher.object";
    rf.short_name = "object";
    rf.receiver_type = "unittest.mock._patcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patcher.multiple";
    rf.short_name = "multiple";
    rf.receiver_type = "unittest.mock._patcher";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._patcher.stopall";
    rf.short_name = "stopall";
    rf.receiver_type = "unittest.mock._patcher";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_920[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock.MagicMixin";
    rt.short_name = "MagicMixin";
    rt.method_names = py_methods_920;
    static const char* py_bases_921[] = { "unittest.mock.Base", NULL };
    rt.embedded_types = py_bases_921;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.MagicMixin.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.mock.MagicMixin";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock.NonCallableMagicMock";
    rt.short_name = "NonCallableMagicMock";
    static const char* py_bases_922[] = { "unittest.mock.MagicMixin", "unittest.mock.NonCallableMock", NULL };
    rt.embedded_types = py_bases_922;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock.MagicMock";
    rt.short_name = "MagicMock";
    static const char* py_bases_923[] = { "unittest.mock.MagicMixin", "unittest.mock.Mock", NULL };
    rt.embedded_types = py_bases_923;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_924[] = { "__init__", "assert_awaited", "assert_awaited_once", "assert_awaited_with", "assert_awaited_once_with", "assert_any_await", "assert_has_awaits", "assert_not_awaited", "reset_mock", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock.AsyncMockMixin";
    rt.short_name = "AsyncMockMixin";
    rt.method_names = py_methods_924;
    static const char* py_bases_925[] = { "unittest.mock.Base", NULL };
    rt.embedded_types = py_bases_925;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.AsyncMockMixin.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.mock.AsyncMockMixin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.AsyncMockMixin.assert_awaited";
    rf.short_name = "assert_awaited";
    rf.receiver_type = "unittest.mock.AsyncMockMixin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.AsyncMockMixin.assert_awaited_once";
    rf.short_name = "assert_awaited_once";
    rf.receiver_type = "unittest.mock.AsyncMockMixin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.AsyncMockMixin.assert_awaited_with";
    rf.short_name = "assert_awaited_with";
    rf.receiver_type = "unittest.mock.AsyncMockMixin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.AsyncMockMixin.assert_awaited_once_with";
    rf.short_name = "assert_awaited_once_with";
    rf.receiver_type = "unittest.mock.AsyncMockMixin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.AsyncMockMixin.assert_any_await";
    rf.short_name = "assert_any_await";
    rf.receiver_type = "unittest.mock.AsyncMockMixin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.AsyncMockMixin.assert_has_awaits";
    rf.short_name = "assert_has_awaits";
    rf.receiver_type = "unittest.mock.AsyncMockMixin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.AsyncMockMixin.assert_not_awaited";
    rf.short_name = "assert_not_awaited";
    rf.receiver_type = "unittest.mock.AsyncMockMixin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.AsyncMockMixin.reset_mock";
    rf.short_name = "reset_mock";
    rf.receiver_type = "unittest.mock.AsyncMockMixin";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_926[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock.AsyncMagicMixin";
    rt.short_name = "AsyncMagicMixin";
    rt.method_names = py_methods_926;
    static const char* py_bases_927[] = { "unittest.mock.MagicMixin", NULL };
    rt.embedded_types = py_bases_927;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.AsyncMagicMixin.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.mock.AsyncMagicMixin";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_928[] = { "reset_mock", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock.AsyncMock";
    rt.short_name = "AsyncMock";
    rt.method_names = py_methods_928;
    static const char* py_bases_929[] = { "unittest.mock.AsyncMockMixin", "unittest.mock.AsyncMagicMixin", "unittest.mock.Mock", NULL };
    rt.embedded_types = py_bases_929;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.AsyncMock.reset_mock";
    rf.short_name = "reset_mock";
    rf.receiver_type = "unittest.mock.AsyncMock";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_930[] = { "__init__", "create_mock", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock.MagicProxy";
    rt.short_name = "MagicProxy";
    rt.method_names = py_methods_930;
    static const char* py_bases_931[] = { "unittest.mock.Base", NULL };
    rt.embedded_types = py_bases_931;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.MagicProxy.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.mock.MagicProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.MagicProxy.create_mock";
    rf.short_name = "create_mock";
    rf.receiver_type = "unittest.mock.MagicProxy";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock._ANY";
    rt.short_name = "_ANY";
    static const char* py_bases_932[] = { "unittest.mock.Any", NULL };
    rt.embedded_types = py_bases_932;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_933[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock._SpecState";
    rt.short_name = "_SpecState";
    rt.method_names = py_methods_933;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock._SpecState.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.mock._SpecState";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock.PropertyMock";
    rt.short_name = "PropertyMock";
    static const char* py_bases_934[] = { "unittest.mock.Mock", NULL };
    rt.embedded_types = py_bases_934;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_935[] = { "__init__", "reset_mock", "wait_until_called", "wait_until_any_call_with", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock.ThreadingMixin";
    rt.short_name = "ThreadingMixin";
    rt.method_names = py_methods_935;
    static const char* py_bases_936[] = { "unittest.mock.Base", NULL };
    rt.embedded_types = py_bases_936;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.ThreadingMixin.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.mock.ThreadingMixin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.ThreadingMixin.reset_mock";
    rf.short_name = "reset_mock";
    rf.receiver_type = "unittest.mock.ThreadingMixin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.ThreadingMixin.wait_until_called";
    rf.short_name = "wait_until_called";
    rf.receiver_type = "unittest.mock.ThreadingMixin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.ThreadingMixin.wait_until_any_call_with";
    rf.short_name = "wait_until_any_call_with";
    rf.receiver_type = "unittest.mock.ThreadingMixin";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.mock.ThreadingMock";
    rt.short_name = "ThreadingMock";
    static const char* py_bases_937[] = { "unittest.mock.ThreadingMixin", "unittest.mock.MagicMixin", "unittest.mock.Mock", NULL };
    rt.embedded_types = py_bases_937;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.create_autospec";
    rf.short_name = "create_autospec";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.mock_open";
    rf.short_name = "mock_open";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.mock.seal";
    rf.short_name = "seal";
    cbm_registry_add_func(reg, rf);

    /* ===== module: unittest.result ===== */
    static const char* py_methods_938[] = { "__init__", "printErrors", "wasSuccessful", "stop", "startTest", "stopTest", "startTestRun", "stopTestRun", "addError", "addFailure", "addSuccess", "addSkip", "addExpectedFailure", "addUnexpectedSuccess", "addSubTest", "addDuration", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.result.TestResult";
    rt.short_name = "TestResult";
    rt.method_names = py_methods_938;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.result.TestResult.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.result.TestResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.result.TestResult.printErrors";
    rf.short_name = "printErrors";
    rf.receiver_type = "unittest.result.TestResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.result.TestResult.wasSuccessful";
    rf.short_name = "wasSuccessful";
    rf.receiver_type = "unittest.result.TestResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.result.TestResult.stop";
    rf.short_name = "stop";
    rf.receiver_type = "unittest.result.TestResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.result.TestResult.startTest";
    rf.short_name = "startTest";
    rf.receiver_type = "unittest.result.TestResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.result.TestResult.stopTest";
    rf.short_name = "stopTest";
    rf.receiver_type = "unittest.result.TestResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.result.TestResult.startTestRun";
    rf.short_name = "startTestRun";
    rf.receiver_type = "unittest.result.TestResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.result.TestResult.stopTestRun";
    rf.short_name = "stopTestRun";
    rf.receiver_type = "unittest.result.TestResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.result.TestResult.addError";
    rf.short_name = "addError";
    rf.receiver_type = "unittest.result.TestResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.result.TestResult.addFailure";
    rf.short_name = "addFailure";
    rf.receiver_type = "unittest.result.TestResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.result.TestResult.addSuccess";
    rf.short_name = "addSuccess";
    rf.receiver_type = "unittest.result.TestResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.result.TestResult.addSkip";
    rf.short_name = "addSkip";
    rf.receiver_type = "unittest.result.TestResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.result.TestResult.addExpectedFailure";
    rf.short_name = "addExpectedFailure";
    rf.receiver_type = "unittest.result.TestResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.result.TestResult.addUnexpectedSuccess";
    rf.short_name = "addUnexpectedSuccess";
    rf.receiver_type = "unittest.result.TestResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.result.TestResult.addSubTest";
    rf.short_name = "addSubTest";
    rf.receiver_type = "unittest.result.TestResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.result.TestResult.addDuration";
    rf.short_name = "addDuration";
    rf.receiver_type = "unittest.result.TestResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.result.failfast";
    rf.short_name = "failfast";
    cbm_registry_add_func(reg, rf);

    /* ===== module: unittest.runner ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.runner._SupportsWriteAndFlush";
    rt.short_name = "_SupportsWriteAndFlush";
    static const char* py_bases_939[] = { "unittest.runner.SupportsFlush", "unittest.runner.Protocol", NULL };
    rt.embedded_types = py_bases_939;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_940[] = { "writeln", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.runner._TextTestStream";
    rt.short_name = "_TextTestStream";
    rt.method_names = py_methods_940;
    static const char* py_bases_941[] = { "unittest.runner._SupportsWriteAndFlush", "unittest.runner.Protocol", NULL };
    rt.embedded_types = py_bases_941;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.runner._TextTestStream.writeln";
    rf.short_name = "writeln";
    rf.receiver_type = "unittest.runner._TextTestStream";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_942[] = { "__init__", "writeln", "flush", "write", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.runner._WritelnDecorator";
    rt.short_name = "_WritelnDecorator";
    rt.method_names = py_methods_942;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.runner._WritelnDecorator.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.runner._WritelnDecorator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.runner._WritelnDecorator.writeln";
    rf.short_name = "writeln";
    rf.receiver_type = "unittest.runner._WritelnDecorator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.runner._WritelnDecorator.flush";
    rf.short_name = "flush";
    rf.receiver_type = "unittest.runner._WritelnDecorator";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.runner._WritelnDecorator.write";
    rf.short_name = "write";
    rf.receiver_type = "unittest.runner._WritelnDecorator";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_943[] = { "__init__", "getDescription", "printErrorList", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.runner.TextTestResult";
    rt.short_name = "TextTestResult";
    rt.method_names = py_methods_943;
    static const char* py_bases_944[] = { "unittest.result.TestResult", NULL };
    rt.embedded_types = py_bases_944;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.runner.TextTestResult.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.runner.TextTestResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.runner.TextTestResult.getDescription";
    rf.short_name = "getDescription";
    rf.receiver_type = "unittest.runner.TextTestResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.runner.TextTestResult.printErrorList";
    rf.short_name = "printErrorList";
    rf.receiver_type = "unittest.runner.TextTestResult";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_945[] = { "__init__", "run", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.runner.TextTestRunner";
    rt.short_name = "TextTestRunner";
    rt.method_names = py_methods_945;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.runner.TextTestRunner.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.runner.TextTestRunner";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.runner.TextTestRunner.run";
    rf.short_name = "run";
    rf.receiver_type = "unittest.runner.TextTestRunner";
    cbm_registry_add_func(reg, rf);

    /* ===== module: unittest.signals ===== */
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.signals.installHandler";
    rf.short_name = "installHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.signals.registerResult";
    rf.short_name = "registerResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.signals.removeResult";
    rf.short_name = "removeResult";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.signals.removeHandler";
    rf.short_name = "removeHandler";
    cbm_registry_add_func(reg, rf);

    /* ===== module: unittest.suite ===== */
    static const char* py_methods_946[] = { "__init__", "__call__", "addTest", "addTests", "run", "debug", "countTestCases", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.suite.BaseTestSuite";
    rt.short_name = "BaseTestSuite";
    rt.method_names = py_methods_946;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.suite.BaseTestSuite.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "unittest.suite.BaseTestSuite";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.suite.BaseTestSuite.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "unittest.suite.BaseTestSuite";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.suite.BaseTestSuite.addTest";
    rf.short_name = "addTest";
    rf.receiver_type = "unittest.suite.BaseTestSuite";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.suite.BaseTestSuite.addTests";
    rf.short_name = "addTests";
    rf.receiver_type = "unittest.suite.BaseTestSuite";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.suite.BaseTestSuite.run";
    rf.short_name = "run";
    rf.receiver_type = "unittest.suite.BaseTestSuite";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.suite.BaseTestSuite.debug";
    rf.short_name = "debug";
    rf.receiver_type = "unittest.suite.BaseTestSuite";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.suite.BaseTestSuite.countTestCases";
    rf.short_name = "countTestCases";
    rf.receiver_type = "unittest.suite.BaseTestSuite";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_947[] = { "run", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.suite.TestSuite";
    rt.short_name = "TestSuite";
    rt.method_names = py_methods_947;
    static const char* py_bases_948[] = { "unittest.suite.BaseTestSuite", NULL };
    rt.embedded_types = py_bases_948;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.suite.TestSuite.run";
    rf.short_name = "run";
    rf.receiver_type = "unittest.suite.TestSuite";
    cbm_registry_add_func(reg, rf);

    /* ===== module: unittest.util ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.util._SupportsDunderLT";
    rt.short_name = "_SupportsDunderLT";
    static const char* py_bases_949[] = { "unittest.util.Protocol", NULL };
    rt.embedded_types = py_bases_949;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.util._SupportsDunderGT";
    rt.short_name = "_SupportsDunderGT";
    static const char* py_bases_950[] = { "unittest.util.Protocol", NULL };
    rt.embedded_types = py_bases_950;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.util._SupportsDunderLE";
    rt.short_name = "_SupportsDunderLE";
    static const char* py_bases_951[] = { "unittest.util.Protocol", NULL };
    rt.embedded_types = py_bases_951;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unittest.util._SupportsDunderGE";
    rt.short_name = "_SupportsDunderGE";
    static const char* py_bases_952[] = { "unittest.util.Protocol", NULL };
    rt.embedded_types = py_bases_952;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.util.safe_repr";
    rf.short_name = "safe_repr";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.util.strclass";
    rf.short_name = "strclass";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.util.sorted_list_difference";
    rf.short_name = "sorted_list_difference";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.util.unorderable_list_difference";
    rf.short_name = "unorderable_list_difference";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unittest.util.three_way_cmp";
    rf.short_name = "three_way_cmp";
    cbm_registry_add_func(reg, rf);

    /* ===== module: urllib.error ===== */
    static const char* py_methods_953[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.error.URLError";
    rt.short_name = "URLError";
    rt.method_names = py_methods_953;
    static const char* py_bases_954[] = { "urllib.error.OSError", NULL };
    rt.embedded_types = py_bases_954;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.error.URLError.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "urllib.error.URLError";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_955[] = { "headers", "reason", "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.error.HTTPError";
    rt.short_name = "HTTPError";
    rt.method_names = py_methods_955;
    static const char* py_bases_956[] = { "urllib.error.URLError", "urllib.error.addinfourl", NULL };
    rt.embedded_types = py_bases_956;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.error.HTTPError.headers";
    rf.short_name = "headers";
    rf.receiver_type = "urllib.error.HTTPError";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.error.HTTPError.reason";
    rf.short_name = "reason";
    rf.receiver_type = "urllib.error.HTTPError";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.error.HTTPError.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "urllib.error.HTTPError";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_957[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.error.ContentTooShortError";
    rt.short_name = "ContentTooShortError";
    rt.method_names = py_methods_957;
    static const char* py_bases_958[] = { "urllib.error.URLError", NULL };
    rt.embedded_types = py_bases_958;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.error.ContentTooShortError.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "urllib.error.ContentTooShortError";
    cbm_registry_add_func(reg, rf);

    /* ===== module: urllib.parse ===== */
    static const char* py_methods_959[] = { "encode", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.parse._ResultMixinStr";
    rt.short_name = "_ResultMixinStr";
    rt.method_names = py_methods_959;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse._ResultMixinStr.encode";
    rf.short_name = "encode";
    rf.receiver_type = "urllib.parse._ResultMixinStr";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_960[] = { "decode", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.parse._ResultMixinBytes";
    rt.short_name = "_ResultMixinBytes";
    rt.method_names = py_methods_960;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse._ResultMixinBytes.decode";
    rf.short_name = "decode";
    rf.receiver_type = "urllib.parse._ResultMixinBytes";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_961[] = { "username", "password", "hostname", "port", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.parse._NetlocResultMixinBase";
    rt.short_name = "_NetlocResultMixinBase";
    rt.method_names = py_methods_961;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse._NetlocResultMixinBase.username";
    rf.short_name = "username";
    rf.receiver_type = "urllib.parse._NetlocResultMixinBase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse._NetlocResultMixinBase.password";
    rf.short_name = "password";
    rf.receiver_type = "urllib.parse._NetlocResultMixinBase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse._NetlocResultMixinBase.hostname";
    rf.short_name = "hostname";
    rf.receiver_type = "urllib.parse._NetlocResultMixinBase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse._NetlocResultMixinBase.port";
    rf.short_name = "port";
    rf.receiver_type = "urllib.parse._NetlocResultMixinBase";
    cbm_registry_add_func(reg, rf);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.parse._NetlocResultMixinStr";
    rt.short_name = "_NetlocResultMixinStr";
    static const char* py_bases_962[] = { "urllib.parse._ResultMixinStr", NULL };
    rt.embedded_types = py_bases_962;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.parse._NetlocResultMixinBytes";
    rt.short_name = "_NetlocResultMixinBytes";
    static const char* py_bases_963[] = { "urllib.parse._ResultMixinBytes", NULL };
    rt.embedded_types = py_bases_963;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.parse._DefragResultBase";
    rt.short_name = "_DefragResultBase";
    static const char* py_bases_964[] = { "urllib.parse.NamedTuple", NULL };
    rt.embedded_types = py_bases_964;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.parse._SplitResultBase";
    rt.short_name = "_SplitResultBase";
    static const char* py_bases_965[] = { "urllib.parse.NamedTuple", NULL };
    rt.embedded_types = py_bases_965;
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.parse._ParseResultBase";
    rt.short_name = "_ParseResultBase";
    static const char* py_bases_966[] = { "urllib.parse.NamedTuple", NULL };
    rt.embedded_types = py_bases_966;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_967[] = { "geturl", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.parse.DefragResult";
    rt.short_name = "DefragResult";
    rt.method_names = py_methods_967;
    static const char* py_bases_968[] = { "urllib.parse._ResultMixinStr", NULL };
    rt.embedded_types = py_bases_968;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.DefragResult.geturl";
    rf.short_name = "geturl";
    rf.receiver_type = "urllib.parse.DefragResult";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_969[] = { "geturl", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.parse.SplitResult";
    rt.short_name = "SplitResult";
    rt.method_names = py_methods_969;
    static const char* py_bases_970[] = { "urllib.parse._NetlocResultMixinStr", NULL };
    rt.embedded_types = py_bases_970;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.SplitResult.geturl";
    rf.short_name = "geturl";
    rf.receiver_type = "urllib.parse.SplitResult";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_971[] = { "geturl", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.parse.ParseResult";
    rt.short_name = "ParseResult";
    rt.method_names = py_methods_971;
    static const char* py_bases_972[] = { "urllib.parse._NetlocResultMixinStr", NULL };
    rt.embedded_types = py_bases_972;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.ParseResult.geturl";
    rf.short_name = "geturl";
    rf.receiver_type = "urllib.parse.ParseResult";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_973[] = { "geturl", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.parse.DefragResultBytes";
    rt.short_name = "DefragResultBytes";
    rt.method_names = py_methods_973;
    static const char* py_bases_974[] = { "urllib.parse._ResultMixinBytes", NULL };
    rt.embedded_types = py_bases_974;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.DefragResultBytes.geturl";
    rf.short_name = "geturl";
    rf.receiver_type = "urllib.parse.DefragResultBytes";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_975[] = { "geturl", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.parse.SplitResultBytes";
    rt.short_name = "SplitResultBytes";
    rt.method_names = py_methods_975;
    static const char* py_bases_976[] = { "urllib.parse._NetlocResultMixinBytes", NULL };
    rt.embedded_types = py_bases_976;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.SplitResultBytes.geturl";
    rf.short_name = "geturl";
    rf.receiver_type = "urllib.parse.SplitResultBytes";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_977[] = { "geturl", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.parse.ParseResultBytes";
    rt.short_name = "ParseResultBytes";
    rt.method_names = py_methods_977;
    static const char* py_bases_978[] = { "urllib.parse._NetlocResultMixinBytes", NULL };
    rt.embedded_types = py_bases_978;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.ParseResultBytes.geturl";
    rf.short_name = "geturl";
    rf.receiver_type = "urllib.parse.ParseResultBytes";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_979[] = { "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.parse._QuoteVia";
    rt.short_name = "_QuoteVia";
    rt.method_names = py_methods_979;
    static const char* py_bases_980[] = { "urllib.parse.Protocol", NULL };
    rt.embedded_types = py_bases_980;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse._QuoteVia.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "urllib.parse._QuoteVia";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.parse_qs";
    rf.short_name = "parse_qs";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.parse_qsl";
    rf.short_name = "parse_qsl";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.quote";
    rf.short_name = "quote";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.quote_from_bytes";
    rf.short_name = "quote_from_bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.quote_plus";
    rf.short_name = "quote_plus";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.unquote";
    rf.short_name = "unquote";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.unquote_to_bytes";
    rf.short_name = "unquote_to_bytes";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.unquote_plus";
    rf.short_name = "unquote_plus";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.urldefrag";
    rf.short_name = "urldefrag";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.urlencode";
    rf.short_name = "urlencode";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.urljoin";
    rf.short_name = "urljoin";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.urlparse";
    rf.short_name = "urlparse";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.urlsplit";
    rf.short_name = "urlsplit";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.urlunparse";
    rf.short_name = "urlunparse";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.urlunsplit";
    rf.short_name = "urlunsplit";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.parse.unwrap";
    rf.short_name = "unwrap";
    cbm_registry_add_func(reg, rf);

    /* ===== module: urllib.request ===== */
    static const char* py_methods_981[] = { "full_url", "__init__", "get_method", "add_header", "add_unredirected_header", "has_header", "remove_header", "get_full_url", "set_proxy", "get_header", "header_items", "has_proxy", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.Request";
    rt.short_name = "Request";
    rt.method_names = py_methods_981;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.Request.full_url";
    rf.short_name = "full_url";
    rf.receiver_type = "urllib.request.Request";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.Request.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "urllib.request.Request";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.Request.get_method";
    rf.short_name = "get_method";
    rf.receiver_type = "urllib.request.Request";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.Request.add_header";
    rf.short_name = "add_header";
    rf.receiver_type = "urllib.request.Request";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.Request.add_unredirected_header";
    rf.short_name = "add_unredirected_header";
    rf.receiver_type = "urllib.request.Request";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.Request.has_header";
    rf.short_name = "has_header";
    rf.receiver_type = "urllib.request.Request";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.Request.remove_header";
    rf.short_name = "remove_header";
    rf.receiver_type = "urllib.request.Request";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.Request.get_full_url";
    rf.short_name = "get_full_url";
    rf.receiver_type = "urllib.request.Request";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.Request.set_proxy";
    rf.short_name = "set_proxy";
    rf.receiver_type = "urllib.request.Request";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.Request.get_header";
    rf.short_name = "get_header";
    rf.receiver_type = "urllib.request.Request";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.Request.header_items";
    rf.short_name = "header_items";
    rf.receiver_type = "urllib.request.Request";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.Request.has_proxy";
    rf.short_name = "has_proxy";
    rf.receiver_type = "urllib.request.Request";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_982[] = { "add_handler", "open", "error", "close", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.OpenerDirector";
    rt.short_name = "OpenerDirector";
    rt.method_names = py_methods_982;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.OpenerDirector.add_handler";
    rf.short_name = "add_handler";
    rf.receiver_type = "urllib.request.OpenerDirector";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.OpenerDirector.open";
    rf.short_name = "open";
    rf.receiver_type = "urllib.request.OpenerDirector";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.OpenerDirector.error";
    rf.short_name = "error";
    rf.receiver_type = "urllib.request.OpenerDirector";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.OpenerDirector.close";
    rf.short_name = "close";
    rf.receiver_type = "urllib.request.OpenerDirector";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_983[] = { "add_parent", "close", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.BaseHandler";
    rt.short_name = "BaseHandler";
    rt.method_names = py_methods_983;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.BaseHandler.add_parent";
    rf.short_name = "add_parent";
    rf.receiver_type = "urllib.request.BaseHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.BaseHandler.close";
    rf.short_name = "close";
    rf.receiver_type = "urllib.request.BaseHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_984[] = { "http_error_default", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.HTTPDefaultErrorHandler";
    rt.short_name = "HTTPDefaultErrorHandler";
    rt.method_names = py_methods_984;
    static const char* py_bases_985[] = { "urllib.request.BaseHandler", NULL };
    rt.embedded_types = py_bases_985;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPDefaultErrorHandler.http_error_default";
    rf.short_name = "http_error_default";
    rf.receiver_type = "urllib.request.HTTPDefaultErrorHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_986[] = { "redirect_request", "http_error_301", "http_error_302", "http_error_303", "http_error_307", "http_error_308", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.HTTPRedirectHandler";
    rt.short_name = "HTTPRedirectHandler";
    rt.method_names = py_methods_986;
    static const char* py_bases_987[] = { "urllib.request.BaseHandler", NULL };
    rt.embedded_types = py_bases_987;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPRedirectHandler.redirect_request";
    rf.short_name = "redirect_request";
    rf.receiver_type = "urllib.request.HTTPRedirectHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPRedirectHandler.http_error_301";
    rf.short_name = "http_error_301";
    rf.receiver_type = "urllib.request.HTTPRedirectHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPRedirectHandler.http_error_302";
    rf.short_name = "http_error_302";
    rf.receiver_type = "urllib.request.HTTPRedirectHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPRedirectHandler.http_error_303";
    rf.short_name = "http_error_303";
    rf.receiver_type = "urllib.request.HTTPRedirectHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPRedirectHandler.http_error_307";
    rf.short_name = "http_error_307";
    rf.receiver_type = "urllib.request.HTTPRedirectHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPRedirectHandler.http_error_308";
    rf.short_name = "http_error_308";
    rf.receiver_type = "urllib.request.HTTPRedirectHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_988[] = { "__init__", "http_request", "http_response", "https_request", "https_response", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.HTTPCookieProcessor";
    rt.short_name = "HTTPCookieProcessor";
    rt.method_names = py_methods_988;
    static const char* py_bases_989[] = { "urllib.request.BaseHandler", NULL };
    rt.embedded_types = py_bases_989;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPCookieProcessor.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "urllib.request.HTTPCookieProcessor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPCookieProcessor.http_request";
    rf.short_name = "http_request";
    rf.receiver_type = "urllib.request.HTTPCookieProcessor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPCookieProcessor.http_response";
    rf.short_name = "http_response";
    rf.receiver_type = "urllib.request.HTTPCookieProcessor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPCookieProcessor.https_request";
    rf.short_name = "https_request";
    rf.receiver_type = "urllib.request.HTTPCookieProcessor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPCookieProcessor.https_response";
    rf.short_name = "https_response";
    rf.receiver_type = "urllib.request.HTTPCookieProcessor";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_990[] = { "__init__", "proxy_open", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.ProxyHandler";
    rt.short_name = "ProxyHandler";
    rt.method_names = py_methods_990;
    static const char* py_bases_991[] = { "urllib.request.BaseHandler", NULL };
    rt.embedded_types = py_bases_991;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.ProxyHandler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "urllib.request.ProxyHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.ProxyHandler.proxy_open";
    rf.short_name = "proxy_open";
    rf.receiver_type = "urllib.request.ProxyHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_992[] = { "add_password", "find_user_password", "is_suburi", "reduce_uri", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.HTTPPasswordMgr";
    rt.short_name = "HTTPPasswordMgr";
    rt.method_names = py_methods_992;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPPasswordMgr.add_password";
    rf.short_name = "add_password";
    rf.receiver_type = "urllib.request.HTTPPasswordMgr";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPPasswordMgr.find_user_password";
    rf.short_name = "find_user_password";
    rf.receiver_type = "urllib.request.HTTPPasswordMgr";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPPasswordMgr.is_suburi";
    rf.short_name = "is_suburi";
    rf.receiver_type = "urllib.request.HTTPPasswordMgr";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPPasswordMgr.reduce_uri";
    rf.short_name = "reduce_uri";
    rf.receiver_type = "urllib.request.HTTPPasswordMgr";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_993[] = { "add_password", "find_user_password", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.HTTPPasswordMgrWithDefaultRealm";
    rt.short_name = "HTTPPasswordMgrWithDefaultRealm";
    rt.method_names = py_methods_993;
    static const char* py_bases_994[] = { "urllib.request.HTTPPasswordMgr", NULL };
    rt.embedded_types = py_bases_994;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPPasswordMgrWithDefaultRealm.add_password";
    rf.short_name = "add_password";
    rf.receiver_type = "urllib.request.HTTPPasswordMgrWithDefaultRealm";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPPasswordMgrWithDefaultRealm.find_user_password";
    rf.short_name = "find_user_password";
    rf.receiver_type = "urllib.request.HTTPPasswordMgrWithDefaultRealm";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_995[] = { "add_password", "update_authenticated", "is_authenticated", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.HTTPPasswordMgrWithPriorAuth";
    rt.short_name = "HTTPPasswordMgrWithPriorAuth";
    rt.method_names = py_methods_995;
    static const char* py_bases_996[] = { "urllib.request.HTTPPasswordMgrWithDefaultRealm", NULL };
    rt.embedded_types = py_bases_996;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPPasswordMgrWithPriorAuth.add_password";
    rf.short_name = "add_password";
    rf.receiver_type = "urllib.request.HTTPPasswordMgrWithPriorAuth";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPPasswordMgrWithPriorAuth.update_authenticated";
    rf.short_name = "update_authenticated";
    rf.receiver_type = "urllib.request.HTTPPasswordMgrWithPriorAuth";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPPasswordMgrWithPriorAuth.is_authenticated";
    rf.short_name = "is_authenticated";
    rf.receiver_type = "urllib.request.HTTPPasswordMgrWithPriorAuth";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_997[] = { "__init__", "http_error_auth_reqed", "http_request", "http_response", "https_request", "https_response", "retry_http_basic_auth", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.AbstractBasicAuthHandler";
    rt.short_name = "AbstractBasicAuthHandler";
    rt.method_names = py_methods_997;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.AbstractBasicAuthHandler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "urllib.request.AbstractBasicAuthHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.AbstractBasicAuthHandler.http_error_auth_reqed";
    rf.short_name = "http_error_auth_reqed";
    rf.receiver_type = "urllib.request.AbstractBasicAuthHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.AbstractBasicAuthHandler.http_request";
    rf.short_name = "http_request";
    rf.receiver_type = "urllib.request.AbstractBasicAuthHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.AbstractBasicAuthHandler.http_response";
    rf.short_name = "http_response";
    rf.receiver_type = "urllib.request.AbstractBasicAuthHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.AbstractBasicAuthHandler.https_request";
    rf.short_name = "https_request";
    rf.receiver_type = "urllib.request.AbstractBasicAuthHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.AbstractBasicAuthHandler.https_response";
    rf.short_name = "https_response";
    rf.receiver_type = "urllib.request.AbstractBasicAuthHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.AbstractBasicAuthHandler.retry_http_basic_auth";
    rf.short_name = "retry_http_basic_auth";
    rf.receiver_type = "urllib.request.AbstractBasicAuthHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_998[] = { "http_error_401", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.HTTPBasicAuthHandler";
    rt.short_name = "HTTPBasicAuthHandler";
    rt.method_names = py_methods_998;
    static const char* py_bases_999[] = { "urllib.request.AbstractBasicAuthHandler", "urllib.request.BaseHandler", NULL };
    rt.embedded_types = py_bases_999;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPBasicAuthHandler.http_error_401";
    rf.short_name = "http_error_401";
    rf.receiver_type = "urllib.request.HTTPBasicAuthHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1000[] = { "http_error_407", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.ProxyBasicAuthHandler";
    rt.short_name = "ProxyBasicAuthHandler";
    rt.method_names = py_methods_1000;
    static const char* py_bases_1001[] = { "urllib.request.AbstractBasicAuthHandler", "urllib.request.BaseHandler", NULL };
    rt.embedded_types = py_bases_1001;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.ProxyBasicAuthHandler.http_error_407";
    rf.short_name = "http_error_407";
    rf.receiver_type = "urllib.request.ProxyBasicAuthHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1002[] = { "__init__", "reset_retry_count", "http_error_auth_reqed", "retry_http_digest_auth", "get_cnonce", "get_authorization", "get_algorithm_impls", "get_entity_digest", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.AbstractDigestAuthHandler";
    rt.short_name = "AbstractDigestAuthHandler";
    rt.method_names = py_methods_1002;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.AbstractDigestAuthHandler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "urllib.request.AbstractDigestAuthHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.AbstractDigestAuthHandler.reset_retry_count";
    rf.short_name = "reset_retry_count";
    rf.receiver_type = "urllib.request.AbstractDigestAuthHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.AbstractDigestAuthHandler.http_error_auth_reqed";
    rf.short_name = "http_error_auth_reqed";
    rf.receiver_type = "urllib.request.AbstractDigestAuthHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.AbstractDigestAuthHandler.retry_http_digest_auth";
    rf.short_name = "retry_http_digest_auth";
    rf.receiver_type = "urllib.request.AbstractDigestAuthHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.AbstractDigestAuthHandler.get_cnonce";
    rf.short_name = "get_cnonce";
    rf.receiver_type = "urllib.request.AbstractDigestAuthHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.AbstractDigestAuthHandler.get_authorization";
    rf.short_name = "get_authorization";
    rf.receiver_type = "urllib.request.AbstractDigestAuthHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.AbstractDigestAuthHandler.get_algorithm_impls";
    rf.short_name = "get_algorithm_impls";
    rf.receiver_type = "urllib.request.AbstractDigestAuthHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.AbstractDigestAuthHandler.get_entity_digest";
    rf.short_name = "get_entity_digest";
    rf.receiver_type = "urllib.request.AbstractDigestAuthHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1003[] = { "http_error_401", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.HTTPDigestAuthHandler";
    rt.short_name = "HTTPDigestAuthHandler";
    rt.method_names = py_methods_1003;
    static const char* py_bases_1004[] = { "urllib.request.BaseHandler", "urllib.request.AbstractDigestAuthHandler", NULL };
    rt.embedded_types = py_bases_1004;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPDigestAuthHandler.http_error_401";
    rf.short_name = "http_error_401";
    rf.receiver_type = "urllib.request.HTTPDigestAuthHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1005[] = { "http_error_407", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.ProxyDigestAuthHandler";
    rt.short_name = "ProxyDigestAuthHandler";
    rt.method_names = py_methods_1005;
    static const char* py_bases_1006[] = { "urllib.request.BaseHandler", "urllib.request.AbstractDigestAuthHandler", NULL };
    rt.embedded_types = py_bases_1006;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.ProxyDigestAuthHandler.http_error_407";
    rf.short_name = "http_error_407";
    rf.receiver_type = "urllib.request.ProxyDigestAuthHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1007[] = { "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request._HTTPConnectionProtocol";
    rt.short_name = "_HTTPConnectionProtocol";
    rt.method_names = py_methods_1007;
    static const char* py_bases_1008[] = { "urllib.request.Protocol", NULL };
    rt.embedded_types = py_bases_1008;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request._HTTPConnectionProtocol.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "urllib.request._HTTPConnectionProtocol";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1009[] = { "__init__", "set_http_debuglevel", "do_request_", "do_open", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.AbstractHTTPHandler";
    rt.short_name = "AbstractHTTPHandler";
    rt.method_names = py_methods_1009;
    static const char* py_bases_1010[] = { "urllib.request.BaseHandler", NULL };
    rt.embedded_types = py_bases_1010;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.AbstractHTTPHandler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "urllib.request.AbstractHTTPHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.AbstractHTTPHandler.set_http_debuglevel";
    rf.short_name = "set_http_debuglevel";
    rf.receiver_type = "urllib.request.AbstractHTTPHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.AbstractHTTPHandler.do_request_";
    rf.short_name = "do_request_";
    rf.receiver_type = "urllib.request.AbstractHTTPHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.AbstractHTTPHandler.do_open";
    rf.short_name = "do_open";
    rf.receiver_type = "urllib.request.AbstractHTTPHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1011[] = { "http_open", "http_request", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.HTTPHandler";
    rt.short_name = "HTTPHandler";
    rt.method_names = py_methods_1011;
    static const char* py_bases_1012[] = { "urllib.request.AbstractHTTPHandler", NULL };
    rt.embedded_types = py_bases_1012;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPHandler.http_open";
    rf.short_name = "http_open";
    rf.receiver_type = "urllib.request.HTTPHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPHandler.http_request";
    rf.short_name = "http_request";
    rf.receiver_type = "urllib.request.HTTPHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1013[] = { "__init__", "https_open", "https_request", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.HTTPSHandler";
    rt.short_name = "HTTPSHandler";
    rt.method_names = py_methods_1013;
    static const char* py_bases_1014[] = { "urllib.request.AbstractHTTPHandler", NULL };
    rt.embedded_types = py_bases_1014;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPSHandler.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "urllib.request.HTTPSHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPSHandler.https_open";
    rf.short_name = "https_open";
    rf.receiver_type = "urllib.request.HTTPSHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPSHandler.https_request";
    rf.short_name = "https_request";
    rf.receiver_type = "urllib.request.HTTPSHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1015[] = { "file_open", "get_names", "open_local_file", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.FileHandler";
    rt.short_name = "FileHandler";
    rt.method_names = py_methods_1015;
    static const char* py_bases_1016[] = { "urllib.request.BaseHandler", NULL };
    rt.embedded_types = py_bases_1016;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.FileHandler.file_open";
    rf.short_name = "file_open";
    rf.receiver_type = "urllib.request.FileHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.FileHandler.get_names";
    rf.short_name = "get_names";
    rf.receiver_type = "urllib.request.FileHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.FileHandler.open_local_file";
    rf.short_name = "open_local_file";
    rf.receiver_type = "urllib.request.FileHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1017[] = { "data_open", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.DataHandler";
    rt.short_name = "DataHandler";
    rt.method_names = py_methods_1017;
    static const char* py_bases_1018[] = { "urllib.request.BaseHandler", NULL };
    rt.embedded_types = py_bases_1018;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.DataHandler.data_open";
    rf.short_name = "data_open";
    rf.receiver_type = "urllib.request.DataHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1019[] = { "__init__", "close", "endtransfer", "file_close", "init", "real_close", "retrfile", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.ftpwrapper";
    rt.short_name = "ftpwrapper";
    rt.method_names = py_methods_1019;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.ftpwrapper.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "urllib.request.ftpwrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.ftpwrapper.close";
    rf.short_name = "close";
    rf.receiver_type = "urllib.request.ftpwrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.ftpwrapper.endtransfer";
    rf.short_name = "endtransfer";
    rf.receiver_type = "urllib.request.ftpwrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.ftpwrapper.file_close";
    rf.short_name = "file_close";
    rf.receiver_type = "urllib.request.ftpwrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.ftpwrapper.init";
    rf.short_name = "init";
    rf.receiver_type = "urllib.request.ftpwrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.ftpwrapper.real_close";
    rf.short_name = "real_close";
    rf.receiver_type = "urllib.request.ftpwrapper";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.ftpwrapper.retrfile";
    rf.short_name = "retrfile";
    rf.receiver_type = "urllib.request.ftpwrapper";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1020[] = { "ftp_open", "connect_ftp", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.FTPHandler";
    rt.short_name = "FTPHandler";
    rt.method_names = py_methods_1020;
    static const char* py_bases_1021[] = { "urllib.request.BaseHandler", NULL };
    rt.embedded_types = py_bases_1021;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.FTPHandler.ftp_open";
    rf.short_name = "ftp_open";
    rf.receiver_type = "urllib.request.FTPHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.FTPHandler.connect_ftp";
    rf.short_name = "connect_ftp";
    rf.receiver_type = "urllib.request.FTPHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1022[] = { "setTimeout", "setMaxConns", "check_cache", "clear_cache", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.CacheFTPHandler";
    rt.short_name = "CacheFTPHandler";
    rt.method_names = py_methods_1022;
    static const char* py_bases_1023[] = { "urllib.request.FTPHandler", NULL };
    rt.embedded_types = py_bases_1023;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.CacheFTPHandler.setTimeout";
    rf.short_name = "setTimeout";
    rf.receiver_type = "urllib.request.CacheFTPHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.CacheFTPHandler.setMaxConns";
    rf.short_name = "setMaxConns";
    rf.receiver_type = "urllib.request.CacheFTPHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.CacheFTPHandler.check_cache";
    rf.short_name = "check_cache";
    rf.receiver_type = "urllib.request.CacheFTPHandler";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.CacheFTPHandler.clear_cache";
    rf.short_name = "clear_cache";
    rf.receiver_type = "urllib.request.CacheFTPHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1024[] = { "unknown_open", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.UnknownHandler";
    rt.short_name = "UnknownHandler";
    rt.method_names = py_methods_1024;
    static const char* py_bases_1025[] = { "urllib.request.BaseHandler", NULL };
    rt.embedded_types = py_bases_1025;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.UnknownHandler.unknown_open";
    rf.short_name = "unknown_open";
    rf.receiver_type = "urllib.request.UnknownHandler";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1026[] = { "http_response", "https_response", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.HTTPErrorProcessor";
    rt.short_name = "HTTPErrorProcessor";
    rt.method_names = py_methods_1026;
    static const char* py_bases_1027[] = { "urllib.request.BaseHandler", NULL };
    rt.embedded_types = py_bases_1027;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPErrorProcessor.http_response";
    rf.short_name = "http_response";
    rf.receiver_type = "urllib.request.HTTPErrorProcessor";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.HTTPErrorProcessor.https_response";
    rf.short_name = "https_response";
    rf.receiver_type = "urllib.request.HTTPErrorProcessor";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1028[] = { "__init__", "open", "open_unknown", "retrieve", "addheader", "cleanup", "close", "http_error", "http_error_default", "open_data", "open_file", "open_ftp", "open_http", "open_https", "open_local_file", "open_unknown_proxy", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.URLopener";
    rt.short_name = "URLopener";
    rt.method_names = py_methods_1028;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.URLopener.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "urllib.request.URLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.URLopener.open";
    rf.short_name = "open";
    rf.receiver_type = "urllib.request.URLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.URLopener.open_unknown";
    rf.short_name = "open_unknown";
    rf.receiver_type = "urllib.request.URLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.URLopener.retrieve";
    rf.short_name = "retrieve";
    rf.receiver_type = "urllib.request.URLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.URLopener.addheader";
    rf.short_name = "addheader";
    rf.receiver_type = "urllib.request.URLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.URLopener.cleanup";
    rf.short_name = "cleanup";
    rf.receiver_type = "urllib.request.URLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.URLopener.close";
    rf.short_name = "close";
    rf.receiver_type = "urllib.request.URLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.URLopener.http_error";
    rf.short_name = "http_error";
    rf.receiver_type = "urllib.request.URLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.URLopener.http_error_default";
    rf.short_name = "http_error_default";
    rf.receiver_type = "urllib.request.URLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.URLopener.open_data";
    rf.short_name = "open_data";
    rf.receiver_type = "urllib.request.URLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.URLopener.open_file";
    rf.short_name = "open_file";
    rf.receiver_type = "urllib.request.URLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.URLopener.open_ftp";
    rf.short_name = "open_ftp";
    rf.receiver_type = "urllib.request.URLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.URLopener.open_http";
    rf.short_name = "open_http";
    rf.receiver_type = "urllib.request.URLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.URLopener.open_https";
    rf.short_name = "open_https";
    rf.receiver_type = "urllib.request.URLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.URLopener.open_local_file";
    rf.short_name = "open_local_file";
    rf.receiver_type = "urllib.request.URLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.URLopener.open_unknown_proxy";
    rf.short_name = "open_unknown_proxy";
    rf.receiver_type = "urllib.request.URLopener";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1029[] = { "prompt_user_passwd", "get_user_passwd", "http_error_301", "http_error_302", "http_error_303", "http_error_307", "http_error_308", "http_error_401", "http_error_407", "http_error_default", "redirect_internal", "retry_http_basic_auth", "retry_https_basic_auth", "retry_proxy_http_basic_auth", "retry_proxy_https_basic_auth", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.request.FancyURLopener";
    rt.short_name = "FancyURLopener";
    rt.method_names = py_methods_1029;
    static const char* py_bases_1030[] = { "urllib.request.URLopener", NULL };
    rt.embedded_types = py_bases_1030;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.FancyURLopener.prompt_user_passwd";
    rf.short_name = "prompt_user_passwd";
    rf.receiver_type = "urllib.request.FancyURLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.FancyURLopener.get_user_passwd";
    rf.short_name = "get_user_passwd";
    rf.receiver_type = "urllib.request.FancyURLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.FancyURLopener.http_error_301";
    rf.short_name = "http_error_301";
    rf.receiver_type = "urllib.request.FancyURLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.FancyURLopener.http_error_302";
    rf.short_name = "http_error_302";
    rf.receiver_type = "urllib.request.FancyURLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.FancyURLopener.http_error_303";
    rf.short_name = "http_error_303";
    rf.receiver_type = "urllib.request.FancyURLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.FancyURLopener.http_error_307";
    rf.short_name = "http_error_307";
    rf.receiver_type = "urllib.request.FancyURLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.FancyURLopener.http_error_308";
    rf.short_name = "http_error_308";
    rf.receiver_type = "urllib.request.FancyURLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.FancyURLopener.http_error_401";
    rf.short_name = "http_error_401";
    rf.receiver_type = "urllib.request.FancyURLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.FancyURLopener.http_error_407";
    rf.short_name = "http_error_407";
    rf.receiver_type = "urllib.request.FancyURLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.FancyURLopener.http_error_default";
    rf.short_name = "http_error_default";
    rf.receiver_type = "urllib.request.FancyURLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.FancyURLopener.redirect_internal";
    rf.short_name = "redirect_internal";
    rf.receiver_type = "urllib.request.FancyURLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.FancyURLopener.retry_http_basic_auth";
    rf.short_name = "retry_http_basic_auth";
    rf.receiver_type = "urllib.request.FancyURLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.FancyURLopener.retry_https_basic_auth";
    rf.short_name = "retry_https_basic_auth";
    rf.receiver_type = "urllib.request.FancyURLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.FancyURLopener.retry_proxy_http_basic_auth";
    rf.short_name = "retry_proxy_http_basic_auth";
    rf.receiver_type = "urllib.request.FancyURLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.FancyURLopener.retry_proxy_https_basic_auth";
    rf.short_name = "retry_proxy_https_basic_auth";
    rf.receiver_type = "urllib.request.FancyURLopener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.urlopen";
    rf.short_name = "urlopen";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.install_opener";
    rf.short_name = "install_opener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.build_opener";
    rf.short_name = "build_opener";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.url2pathname";
    rf.short_name = "url2pathname";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.pathname2url";
    rf.short_name = "pathname2url";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.getproxies";
    rf.short_name = "getproxies";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.getproxies_environment";
    rf.short_name = "getproxies_environment";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.parse_http_list";
    rf.short_name = "parse_http_list";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.parse_keqv_list";
    rf.short_name = "parse_keqv_list";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.proxy_bypass";
    rf.short_name = "proxy_bypass";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.urlretrieve";
    rf.short_name = "urlretrieve";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.request.urlcleanup";
    rf.short_name = "urlcleanup";
    cbm_registry_add_func(reg, rf);

    /* ===== module: urllib.response ===== */
    static const char* py_methods_1031[] = { "__init__", "__exit__", "write", "writelines", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.response.addbase";
    rt.short_name = "addbase";
    rt.method_names = py_methods_1031;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.response.addbase.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "urllib.response.addbase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.response.addbase.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "urllib.response.addbase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.response.addbase.write";
    rf.short_name = "write";
    rf.receiver_type = "urllib.response.addbase";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.response.addbase.writelines";
    rf.short_name = "writelines";
    rf.receiver_type = "urllib.response.addbase";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1032[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.response.addclosehook";
    rt.short_name = "addclosehook";
    rt.method_names = py_methods_1032;
    static const char* py_bases_1033[] = { "urllib.response.addbase", NULL };
    rt.embedded_types = py_bases_1033;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.response.addclosehook.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "urllib.response.addclosehook";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1034[] = { "__init__", "info", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.response.addinfo";
    rt.short_name = "addinfo";
    rt.method_names = py_methods_1034;
    static const char* py_bases_1035[] = { "urllib.response.addbase", NULL };
    rt.embedded_types = py_bases_1035;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.response.addinfo.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "urllib.response.addinfo";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.response.addinfo.info";
    rf.short_name = "info";
    rf.receiver_type = "urllib.response.addinfo";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1036[] = { "status", "__init__", "geturl", "info", "getcode", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.response.addinfourl";
    rt.short_name = "addinfourl";
    rt.method_names = py_methods_1036;
    static const char* py_bases_1037[] = { "urllib.response.addinfo", NULL };
    rt.embedded_types = py_bases_1037;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.response.addinfourl.status";
    rf.short_name = "status";
    rf.receiver_type = "urllib.response.addinfourl";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.response.addinfourl.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "urllib.response.addinfourl";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.response.addinfourl.geturl";
    rf.short_name = "geturl";
    rf.receiver_type = "urllib.response.addinfourl";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.response.addinfourl.info";
    rf.short_name = "info";
    rf.receiver_type = "urllib.response.addinfourl";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.response.addinfourl.getcode";
    rf.short_name = "getcode";
    rf.receiver_type = "urllib.response.addinfourl";
    cbm_registry_add_func(reg, rf);

    /* ===== module: urllib.robotparser ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.robotparser.RequestRate";
    rt.short_name = "RequestRate";
    static const char* py_bases_1038[] = { "urllib.robotparser.NamedTuple", NULL };
    rt.embedded_types = py_bases_1038;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_1039[] = { "__init__", "set_url", "read", "parse", "can_fetch", "mtime", "modified", "crawl_delay", "request_rate", "site_maps", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "urllib.robotparser.RobotFileParser";
    rt.short_name = "RobotFileParser";
    rt.method_names = py_methods_1039;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.robotparser.RobotFileParser.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "urllib.robotparser.RobotFileParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.robotparser.RobotFileParser.set_url";
    rf.short_name = "set_url";
    rf.receiver_type = "urllib.robotparser.RobotFileParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.robotparser.RobotFileParser.read";
    rf.short_name = "read";
    rf.receiver_type = "urllib.robotparser.RobotFileParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.robotparser.RobotFileParser.parse";
    rf.short_name = "parse";
    rf.receiver_type = "urllib.robotparser.RobotFileParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.robotparser.RobotFileParser.can_fetch";
    rf.short_name = "can_fetch";
    rf.receiver_type = "urllib.robotparser.RobotFileParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.robotparser.RobotFileParser.mtime";
    rf.short_name = "mtime";
    rf.receiver_type = "urllib.robotparser.RobotFileParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.robotparser.RobotFileParser.modified";
    rf.short_name = "modified";
    rf.receiver_type = "urllib.robotparser.RobotFileParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.robotparser.RobotFileParser.crawl_delay";
    rf.short_name = "crawl_delay";
    rf.receiver_type = "urllib.robotparser.RobotFileParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.robotparser.RobotFileParser.request_rate";
    rf.short_name = "request_rate";
    rf.receiver_type = "urllib.robotparser.RobotFileParser";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "urllib.robotparser.RobotFileParser.site_maps";
    rf.short_name = "site_maps";
    rf.receiver_type = "urllib.robotparser.RobotFileParser";
    cbm_registry_add_func(reg, rf);

    /* ===== module: warnings ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "warnings._OptionError";
    rt.short_name = "_OptionError";
    static const char* py_bases_1040[] = { "warnings.Exception", NULL };
    rt.embedded_types = py_bases_1040;
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_1041[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "warnings.WarningMessage";
    rt.short_name = "WarningMessage";
    rt.method_names = py_methods_1041;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "warnings.WarningMessage.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "warnings.WarningMessage";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1042[] = { "__init__", "__enter__", "__exit__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "warnings.catch_warnings";
    rt.short_name = "catch_warnings";
    rt.method_names = py_methods_1042;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "warnings.catch_warnings.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "warnings.catch_warnings";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "warnings.catch_warnings.__enter__";
    rf.short_name = "__enter__";
    rf.receiver_type = "warnings.catch_warnings";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "warnings.catch_warnings.__exit__";
    rf.short_name = "__exit__";
    rf.receiver_type = "warnings.catch_warnings";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1043[] = { "__init__", "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "warnings.deprecated";
    rt.short_name = "deprecated";
    rt.method_names = py_methods_1043;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "warnings.deprecated.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "warnings.deprecated";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "warnings.deprecated.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "warnings.deprecated";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "warnings.showwarning";
    rf.short_name = "showwarning";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "warnings.formatwarning";
    rf.short_name = "formatwarning";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "warnings.filterwarnings";
    rf.short_name = "filterwarnings";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "warnings.simplefilter";
    rf.short_name = "simplefilter";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "warnings.resetwarnings";
    rf.short_name = "resetwarnings";
    cbm_registry_add_func(reg, rf);

    /* ===== module: weakref ===== */
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "weakref.CallableProxyType";
    rt.short_name = "CallableProxyType";
    cbm_registry_add_type(reg, rt);
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "weakref.ProxyType";
    rt.short_name = "ProxyType";
    cbm_registry_add_type(reg, rt);
    static const char* py_methods_1044[] = { "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "weakref.ReferenceType";
    rt.short_name = "ReferenceType";
    rt.method_names = py_methods_1044;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.ReferenceType.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "weakref.ReferenceType";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1045[] = { "__call__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "weakref.WeakMethod";
    rt.short_name = "WeakMethod";
    rt.method_names = py_methods_1045;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakMethod.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "weakref.WeakMethod";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1046[] = { "__init__", "copy", "get", "keys", "values", "items", "itervaluerefs", "valuerefs", "setdefault", "pop", "update", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "weakref.WeakValueDictionary";
    rt.short_name = "WeakValueDictionary";
    rt.method_names = py_methods_1046;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakValueDictionary.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "weakref.WeakValueDictionary";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakValueDictionary.copy";
    rf.short_name = "copy";
    rf.receiver_type = "weakref.WeakValueDictionary";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakValueDictionary.get";
    rf.short_name = "get";
    rf.receiver_type = "weakref.WeakValueDictionary";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakValueDictionary.keys";
    rf.short_name = "keys";
    rf.receiver_type = "weakref.WeakValueDictionary";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakValueDictionary.values";
    rf.short_name = "values";
    rf.receiver_type = "weakref.WeakValueDictionary";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakValueDictionary.items";
    rf.short_name = "items";
    rf.receiver_type = "weakref.WeakValueDictionary";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakValueDictionary.itervaluerefs";
    rf.short_name = "itervaluerefs";
    rf.receiver_type = "weakref.WeakValueDictionary";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakValueDictionary.valuerefs";
    rf.short_name = "valuerefs";
    rf.receiver_type = "weakref.WeakValueDictionary";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakValueDictionary.setdefault";
    rf.short_name = "setdefault";
    rf.receiver_type = "weakref.WeakValueDictionary";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakValueDictionary.pop";
    rf.short_name = "pop";
    rf.receiver_type = "weakref.WeakValueDictionary";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakValueDictionary.update";
    rf.short_name = "update";
    rf.receiver_type = "weakref.WeakValueDictionary";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1047[] = { "__init__", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "weakref.KeyedRef";
    rt.short_name = "KeyedRef";
    rt.method_names = py_methods_1047;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.KeyedRef.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "weakref.KeyedRef";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1048[] = { "__init__", "copy", "get", "keys", "values", "items", "keyrefs", "setdefault", "pop", "update", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "weakref.WeakKeyDictionary";
    rt.short_name = "WeakKeyDictionary";
    rt.method_names = py_methods_1048;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakKeyDictionary.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "weakref.WeakKeyDictionary";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakKeyDictionary.copy";
    rf.short_name = "copy";
    rf.receiver_type = "weakref.WeakKeyDictionary";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakKeyDictionary.get";
    rf.short_name = "get";
    rf.receiver_type = "weakref.WeakKeyDictionary";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakKeyDictionary.keys";
    rf.short_name = "keys";
    rf.receiver_type = "weakref.WeakKeyDictionary";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakKeyDictionary.values";
    rf.short_name = "values";
    rf.receiver_type = "weakref.WeakKeyDictionary";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakKeyDictionary.items";
    rf.short_name = "items";
    rf.receiver_type = "weakref.WeakKeyDictionary";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakKeyDictionary.keyrefs";
    rf.short_name = "keyrefs";
    rf.receiver_type = "weakref.WeakKeyDictionary";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakKeyDictionary.setdefault";
    rf.short_name = "setdefault";
    rf.receiver_type = "weakref.WeakKeyDictionary";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakKeyDictionary.pop";
    rf.short_name = "pop";
    rf.receiver_type = "weakref.WeakKeyDictionary";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.WeakKeyDictionary.update";
    rf.short_name = "update";
    rf.receiver_type = "weakref.WeakKeyDictionary";
    cbm_registry_add_func(reg, rf);
    static const char* py_methods_1049[] = { "__init__", "__call__", "detach", "peek", "alive", NULL };
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "weakref.finalize";
    rt.short_name = "finalize";
    rt.method_names = py_methods_1049;
    cbm_registry_add_type(reg, rt);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.finalize.__init__";
    rf.short_name = "__init__";
    rf.receiver_type = "weakref.finalize";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.finalize.__call__";
    rf.short_name = "__call__";
    rf.receiver_type = "weakref.finalize";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.finalize.detach";
    rf.short_name = "detach";
    rf.receiver_type = "weakref.finalize";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.finalize.peek";
    rf.short_name = "peek";
    rf.receiver_type = "weakref.finalize";
    cbm_registry_add_func(reg, rf);
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "weakref.finalize.alive";
    rf.short_name = "alive";
    rf.receiver_type = "weakref.finalize";
    cbm_registry_add_func(reg, rf);
}