// SDB-CGEN V2.6.2
#include <ctype.h>
#include <stdio.h>
#include <string.h>

struct kv { const char *name; const char *value; };
static const struct kv kvs[] = {
// gcc -DMAIN=1 types_glib.c ; ./a.out > types_glib.h
	{"GBytes", "typedef"},
	{"GCompareFunc", "typedef"},
	{"GDestroyNotify", "typedef"},
	{"GDuplicateFunc", "typedef"},
	{"GEqualFunc", "typedef"},
	{"GError", "typedef"},
	{"GFileTest", "enum"},
	{"GHashFunc", "typedef"},
	{"GHashTable", "typedef"},
	{"GKeyFile", "typedef"},
	{"GKeyFileFlags", "enum"},
	{"GList", "typedef"},
	{"GNormalizeMode", "enum"},
	{"GOptionContext", "typedef"},
	{"GOptionEntry", "typedef"},
	{"GOptionGroup", "typedef"},
	{"GPrintFunc", "typedef"},
	{"GPtrArray", "typedef"},
	{"GQuark", "typedef"},
	{"GString", "typedef"},
	{"GStringChunk", "typedef"},
	{"GStrv", "typedef"},
	{"GVariant", "typedef"},
	{"GVariantDict", "typedef"},
	{"GVariantIter", "typedef"},
	{"GVariantType", "typedef"},
	{"enum.GFileTest", "G_FILE_TEST_IS_REGULAR,G_FILE_TEST_IS_SYMLINK,G_FILE_TEST_IS_DIR,G_FILE_TEST_IS_EXECUTABLE,G_FILE_TEST_EXISTS"},
	{"enum.GFileTest.0x1", "G_FILE_TEST_IS_REGULAR"},
	{"enum.GFileTest.0x10", "G_FILE_TEST_EXISTS"},
	{"enum.GFileTest.0x2", "G_FILE_TEST_IS_SYMLINK"},
	{"enum.GFileTest.0x4", "G_FILE_TEST_IS_DIR"},
	{"enum.GFileTest.0x8", "G_FILE_TEST_IS_EXECUTABLE"},
	{"enum.GFileTest.G_FILE_TEST_EXISTS", "0x10"},
	{"enum.GFileTest.G_FILE_TEST_IS_DIR", "0x4"},
	{"enum.GFileTest.G_FILE_TEST_IS_EXECUTABLE", "0x8"},
	{"enum.GFileTest.G_FILE_TEST_IS_REGULAR", "0x1"},
	{"enum.GFileTest.G_FILE_TEST_IS_SYMLINK", "0x2"},
	{"enum.GKeyFileFlags", "G_KEY_FILE_NONE,G_KEY_FILE_KEEP_COMMENTS,G_KEY_FILE_KEEP_TRANSLATIONS"},
	{"enum.GKeyFileFlags.0x0", "G_KEY_FILE_NONE"},
	{"enum.GKeyFileFlags.0x1", "G_KEY_FILE_KEEP_COMMENTS"},
	{"enum.GKeyFileFlags.0x2", "G_KEY_FILE_KEEP_TRANSLATIONS"},
	{"enum.GKeyFileFlags.G_KEY_FILE_KEEP_COMMENTS", "0x1"},
	{"enum.GKeyFileFlags.G_KEY_FILE_KEEP_TRANSLATIONS", "0x2"},
	{"enum.GKeyFileFlags.G_KEY_FILE_NONE", "0x0"},
	{"enum.GNormalizeMode", "G_NORMALIZE_DEFAULT,G_NORMALIZE_NFD,G_NORMALIZE_DEFAULT_COMPOSE,G_NORMALIZE_NFC,G_NORMALIZE_ALL,G_NORMALIZE_NFKD,G_NORMALIZE_ALL_COMPOSE,G_NORMALIZE_NFKC"},
	{"enum.GNormalizeMode.0x0", "G_NORMALIZE_DEFAULT"},
	{"enum.GNormalizeMode.0x1", "G_NORMALIZE_DEFAULT_COMPOSE"},
	{"enum.GNormalizeMode.0x2", "G_NORMALIZE_ALL"},
	{"enum.GNormalizeMode.0x3", "G_NORMALIZE_ALL_COMPOSE"},
	{"enum.GNormalizeMode.G_NORMALIZE_ALL", "0x2"},
	{"enum.GNormalizeMode.G_NORMALIZE_ALL_COMPOSE", "0x3"},
	{"enum.GNormalizeMode.G_NORMALIZE_DEFAULT", "0x0"},
	{"enum.GNormalizeMode.G_NORMALIZE_DEFAULT_COMPOSE", "0x1"},
	{"enum.GNormalizeMode.G_NORMALIZE_NFC", "0x1"},
	{"enum.GNormalizeMode.G_NORMALIZE_NFD", "0x0"},
	{"enum.GNormalizeMode.G_NORMALIZE_NFKC", "0x3"},
	{"enum.GNormalizeMode.G_NORMALIZE_NFKD", "0x2"},
	{"func.g_aligned_alloc.arg.0", "gsize,n_blocks"},
	{"func.g_aligned_alloc.arg.1", "gsize,n_block_bytes"},
	{"func.g_aligned_alloc.arg.2", "gsize,alignment"},
	{"func.g_aligned_alloc.args", "3"},
	{"func.g_aligned_alloc.ret", "gpointer"},
	{"func.g_aligned_alloc0.arg.0", "gsize,n_blocks"},
	{"func.g_aligned_alloc0.arg.1", "gsize,n_block_bytes"},
	{"func.g_aligned_alloc0.arg.2", "gsize,alignment"},
	{"func.g_aligned_alloc0.args", "3"},
	{"func.g_aligned_alloc0.ret", "gpointer"},
	{"func.g_aligned_free.arg.0", "gpointer,mem"},
	{"func.g_aligned_free.args", "1"},
	{"func.g_aligned_free.ret", "void"},
	{"func.g_aligned_free_sized.arg.0", "gpointer,mem"},
	{"func.g_aligned_free_sized.arg.1", "size_t,alignment"},
	{"func.g_aligned_free_sized.arg.2", "size_t,size"},
	{"func.g_aligned_free_sized.args", "3"},
	{"func.g_aligned_free_sized.ret", "void"},
	{"func.g_ascii_digit_value.arg.0", "gchar,c"},
	{"func.g_ascii_digit_value.args", "1"},
	{"func.g_ascii_digit_value.ret", "gint"},
	{"func.g_ascii_dtostr.arg.0", "gchar *,buffer"},
	{"func.g_ascii_dtostr.arg.1", "gint,buf_len"},
	{"func.g_ascii_dtostr.arg.2", "gdouble,d"},
	{"func.g_ascii_dtostr.args", "3"},
	{"func.g_ascii_dtostr.ret", "gchar *"},
	{"func.g_ascii_formatd.arg.0", "gchar *,buffer"},
	{"func.g_ascii_formatd.arg.1", "gint,buf_len"},
	{"func.g_ascii_formatd.arg.2", "const gchar *,format"},
	{"func.g_ascii_formatd.arg.3", "gdouble,d"},
	{"func.g_ascii_formatd.args", "4"},
	{"func.g_ascii_formatd.ret", "gchar *"},
	{"func.g_ascii_strcasecmp.arg.0", "const gchar *,s1"},
	{"func.g_ascii_strcasecmp.arg.1", "const gchar *,s2"},
	{"func.g_ascii_strcasecmp.args", "2"},
	{"func.g_ascii_strcasecmp.ret", "gint"},
	{"func.g_ascii_strdown.arg.0", "const gchar *,str"},
	{"func.g_ascii_strdown.arg.1", "gssize,len"},
	{"func.g_ascii_strdown.args", "2"},
	{"func.g_ascii_strdown.ret", "gchar *"},
	{"func.g_ascii_string_to_signed.arg.0", "const gchar *,str"},
	{"func.g_ascii_string_to_signed.arg.1", "guint,base"},
	{"func.g_ascii_string_to_signed.arg.2", "gint64,min"},
	{"func.g_ascii_string_to_signed.arg.3", "gint64,max"},
	{"func.g_ascii_string_to_signed.arg.4", "gint64 *,out_num"},
	{"func.g_ascii_string_to_signed.arg.5", "GError **,error"},
	{"func.g_ascii_string_to_signed.args", "6"},
	{"func.g_ascii_string_to_signed.ret", "gboolean"},
	{"func.g_ascii_string_to_unsigned.arg.0", "const gchar *,str"},
	{"func.g_ascii_string_to_unsigned.arg.1", "guint,base"},
	{"func.g_ascii_string_to_unsigned.arg.2", "guint64,min"},
	{"func.g_ascii_string_to_unsigned.arg.3", "guint64,max"},
	{"func.g_ascii_string_to_unsigned.arg.4", "guint64 *,out_num"},
	{"func.g_ascii_string_to_unsigned.arg.5", "GError **,error"},
	{"func.g_ascii_string_to_unsigned.args", "6"},
	{"func.g_ascii_string_to_unsigned.ret", "gboolean"},
	{"func.g_ascii_strncasecmp.arg.0", "const gchar *,s1"},
	{"func.g_ascii_strncasecmp.arg.1", "const gchar *,s2"},
	{"func.g_ascii_strncasecmp.arg.2", "gsize,n"},
	{"func.g_ascii_strncasecmp.args", "3"},
	{"func.g_ascii_strncasecmp.ret", "gint"},
	{"func.g_ascii_strtod.arg.0", "const gchar *,nptr"},
	{"func.g_ascii_strtod.arg.1", "gchar **,endptr"},
	{"func.g_ascii_strtod.args", "2"},
	{"func.g_ascii_strtod.ret", "gdouble"},
	{"func.g_ascii_strtoll.arg.0", "const gchar *,nptr"},
	{"func.g_ascii_strtoll.arg.1", "gchar **,endptr"},
	{"func.g_ascii_strtoll.arg.2", "guint,base"},
	{"func.g_ascii_strtoll.args", "3"},
	{"func.g_ascii_strtoll.ret", "gint64"},
	{"func.g_ascii_strtoull.arg.0", "const gchar *,nptr"},
	{"func.g_ascii_strtoull.arg.1", "gchar **,endptr"},
	{"func.g_ascii_strtoull.arg.2", "guint,base"},
	{"func.g_ascii_strtoull.args", "3"},
	{"func.g_ascii_strtoull.ret", "guint64"},
	{"func.g_ascii_strup.arg.0", "const gchar *,str"},
	{"func.g_ascii_strup.arg.1", "gssize,len"},
	{"func.g_ascii_strup.args", "2"},
	{"func.g_ascii_strup.ret", "gchar *"},
	{"func.g_ascii_tolower.arg.0", "gchar,c"},
	{"func.g_ascii_tolower.args", "1"},
	{"func.g_ascii_tolower.ret", "gchar"},
	{"func.g_ascii_toupper.arg.0", "gchar,c"},
	{"func.g_ascii_toupper.args", "1"},
	{"func.g_ascii_toupper.ret", "gchar"},
	{"func.g_ascii_xdigit_value.arg.0", "gchar,c"},
	{"func.g_ascii_xdigit_value.args", "1"},
	{"func.g_ascii_xdigit_value.ret", "gint"},
	{"func.g_base64_decode.arg.0", "const gchar *,text"},
	{"func.g_base64_decode.arg.1", "gsize *,out_len"},
	{"func.g_base64_decode.args", "2"},
	{"func.g_base64_decode.ret", "guchar *"},
	{"func.g_base64_decode_inplace.arg.0", "gchar *,text"},
	{"func.g_base64_decode_inplace.arg.1", "gsize *,out_len"},
	{"func.g_base64_decode_inplace.args", "2"},
	{"func.g_base64_decode_inplace.ret", "guchar *"},
	{"func.g_base64_decode_step.arg.0", "const gchar *,in"},
	{"func.g_base64_decode_step.arg.1", "gsize,len"},
	{"func.g_base64_decode_step.arg.2", "guchar *,out"},
	{"func.g_base64_decode_step.arg.3", "gint *,state"},
	{"func.g_base64_decode_step.arg.4", "guint *,save"},
	{"func.g_base64_decode_step.args", "5"},
	{"func.g_base64_decode_step.ret", "gsize"},
	{"func.g_base64_encode.arg.0", "const guchar *,data"},
	{"func.g_base64_encode.arg.1", "gsize,len"},
	{"func.g_base64_encode.args", "2"},
	{"func.g_base64_encode.ret", "gchar *"},
	{"func.g_base64_encode_close.arg.0", "gboolean,break_lines"},
	{"func.g_base64_encode_close.arg.1", "gchar *,out"},
	{"func.g_base64_encode_close.arg.2", "gint *,state"},
	{"func.g_base64_encode_close.arg.3", "gint *,save"},
	{"func.g_base64_encode_close.args", "4"},
	{"func.g_base64_encode_close.ret", "gsize"},
	{"func.g_base64_encode_step.arg.0", "const guchar *,in"},
	{"func.g_base64_encode_step.arg.1", "gsize,len"},
	{"func.g_base64_encode_step.arg.2", "gboolean,break_lines"},
	{"func.g_base64_encode_step.arg.3", "gchar *,out"},
	{"func.g_base64_encode_step.arg.4", "gint *,state"},
	{"func.g_base64_encode_step.arg.5", "gint *,save"},
	{"func.g_base64_encode_step.args", "6"},
	{"func.g_base64_encode_step.ret", "gsize"},
	{"func.g_build_filename.arg.0", "const gchar *,first_element"},
	{"func.g_build_filename.arg.1", ",..."},
	{"func.g_build_filename.args", "2"},
	{"func.g_build_filename.ret", "gchar *"},
	{"func.g_build_filenamev.arg.0", "gchar **,args"},
	{"func.g_build_filenamev.args", "1"},
	{"func.g_build_filenamev.ret", "gchar *"},
	{"func.g_build_path.arg.0", "const gchar *,separator"},
	{"func.g_build_path.arg.1", "const gchar *,first_element"},
	{"func.g_build_path.arg.2", ",..."},
	{"func.g_build_path.args", "3"},
	{"func.g_build_path.ret", "gchar *"},
	{"func.g_build_pathv.arg.0", "const gchar *,separator"},
	{"func.g_build_pathv.arg.1", "gchar **,args"},
	{"func.g_build_pathv.args", "2"},
	{"func.g_build_pathv.ret", "gchar *"},
	{"func.g_canonicalize_filename.arg.0", "const gchar *,filename"},
	{"func.g_canonicalize_filename.arg.1", "const gchar *,relative_to"},
	{"func.g_canonicalize_filename.args", "2"},
	{"func.g_canonicalize_filename.ret", "gchar *"},
	{"func.g_clear_error.arg.0", "GError **,err"},
	{"func.g_clear_error.args", "1"},
	{"func.g_clear_error.ret", "void"},
	{"func.g_dir_make_tmp.arg.0", "const gchar *,tmpl"},
	{"func.g_dir_make_tmp.arg.1", "GError **,error"},
	{"func.g_dir_make_tmp.args", "2"},
	{"func.g_dir_make_tmp.ret", "gchar *"},
	{"func.g_environ_getenv.arg.0", "gchar **,envp"},
	{"func.g_environ_getenv.arg.1", "const gchar *,variable"},
	{"func.g_environ_getenv.args", "2"},
	{"func.g_environ_getenv.ret", "const gchar *"},
	{"func.g_environ_setenv.arg.0", "gchar **,envp"},
	{"func.g_environ_setenv.arg.1", "const gchar *,variable"},
	{"func.g_environ_setenv.arg.2", "const gchar *,value"},
	{"func.g_environ_setenv.arg.3", "gboolean,overwrite"},
	{"func.g_environ_setenv.args", "4"},
	{"func.g_environ_setenv.ret", "gchar **"},
	{"func.g_environ_unsetenv.arg.0", "gchar **,envp"},
	{"func.g_environ_unsetenv.arg.1", "const gchar *,variable"},
	{"func.g_environ_unsetenv.args", "2"},
	{"func.g_environ_unsetenv.ret", "gchar **"},
	{"func.g_error_copy.arg.0", "const GError *,error"},
	{"func.g_error_copy.args", "1"},
	{"func.g_error_copy.ret", "GError *"},
	{"func.g_error_free.arg.0", "GError *,error"},
	{"func.g_error_free.args", "1"},
	{"func.g_error_free.ret", "void"},
	{"func.g_error_matches.arg.0", "const GError *,error"},
	{"func.g_error_matches.arg.1", "GQuark,domain"},
	{"func.g_error_matches.arg.2", "gint,code"},
	{"func.g_error_matches.args", "3"},
	{"func.g_error_matches.ret", "gboolean"},
	{"func.g_error_new.arg.0", "GQuark,domain"},
	{"func.g_error_new.arg.1", "gint,code"},
	{"func.g_error_new.arg.2", "const gchar *,format"},
	{"func.g_error_new.arg.3", ",..."},
	{"func.g_error_new.args", "4"},
	{"func.g_error_new.ret", "GError *"},
	{"func.g_error_new_literal.arg.0", "GQuark,domain"},
	{"func.g_error_new_literal.arg.1", "gint,code"},
	{"func.g_error_new_literal.arg.2", "const gchar *,message"},
	{"func.g_error_new_literal.args", "3"},
	{"func.g_error_new_literal.ret", "GError *"},
	{"func.g_error_new_valist.arg.0", "GQuark,domain"},
	{"func.g_error_new_valist.arg.1", "gint,code"},
	{"func.g_error_new_valist.arg.2", "const gchar *,format"},
	{"func.g_error_new_valist.arg.3", "va_list,args"},
	{"func.g_error_new_valist.args", "4"},
	{"func.g_error_new_valist.ret", "GError *"},
	{"func.g_file_get_contents.arg.0", "const gchar *,filename"},
	{"func.g_file_get_contents.arg.1", "gchar **,contents"},
	{"func.g_file_get_contents.arg.2", "gsize *,length"},
	{"func.g_file_get_contents.arg.3", "GError **,error"},
	{"func.g_file_get_contents.args", "4"},
	{"func.g_file_get_contents.ret", "gboolean"},
	{"func.g_file_read_link.arg.0", "const gchar *,filename"},
	{"func.g_file_read_link.arg.1", "GError **,error"},
	{"func.g_file_read_link.args", "2"},
	{"func.g_file_read_link.ret", "gchar *"},
	{"func.g_file_set_contents.arg.0", "const gchar *,filename"},
	{"func.g_file_set_contents.arg.1", "const gchar *,contents"},
	{"func.g_file_set_contents.arg.2", "gssize,length"},
	{"func.g_file_set_contents.arg.3", "GError **,error"},
	{"func.g_file_set_contents.args", "4"},
	{"func.g_file_set_contents.ret", "gboolean"},
	{"func.g_file_test.arg.0", "const gchar *,filename"},
	{"func.g_file_test.arg.1", "GFileTest,test"},
	{"func.g_file_test.args", "2"},
	{"func.g_file_test.ret", "gboolean"},
	{"func.g_free.arg.0", "gpointer,mem"},
	{"func.g_free.args", "1"},
	{"func.g_free.ret", "void"},
	{"func.g_free_sized.arg.0", "gpointer,mem"},
	{"func.g_free_sized.arg.1", "size_t,size"},
	{"func.g_free_sized.args", "2"},
	{"func.g_free_sized.ret", "void"},
	{"func.g_get_current_dir.args", "0"},
	{"func.g_get_current_dir.ret", "gchar *"},
	{"func.g_get_environ.args", "0"},
	{"func.g_get_environ.ret", "gchar **"},
	{"func.g_get_home_dir.args", "0"},
	{"func.g_get_home_dir.ret", "const gchar *"},
	{"func.g_get_prgname.args", "0"},
	{"func.g_get_prgname.ret", "const gchar *"},
	{"func.g_get_tmp_dir.args", "0"},
	{"func.g_get_tmp_dir.ret", "const gchar *"},
	{"func.g_get_user_cache_dir.args", "0"},
	{"func.g_get_user_cache_dir.ret", "const gchar *"},
	{"func.g_get_user_data_dir.args", "0"},
	{"func.g_get_user_data_dir.ret", "const gchar *"},
	{"func.g_get_user_name.args", "0"},
	{"func.g_get_user_name.ret", "const gchar *"},
	{"func.g_getenv.arg.0", "const gchar *,variable"},
	{"func.g_getenv.args", "1"},
	{"func.g_getenv.ret", "const gchar *"},
	{"func.g_hash_table_contains.arg.0", "GHashTable *,hash_table"},
	{"func.g_hash_table_contains.arg.1", "gconstpointer,key"},
	{"func.g_hash_table_contains.args", "2"},
	{"func.g_hash_table_contains.ret", "gboolean"},
	{"func.g_hash_table_destroy.arg.0", "GHashTable *,hash_table"},
	{"func.g_hash_table_destroy.args", "1"},
	{"func.g_hash_table_destroy.ret", "void"},
	{"func.g_hash_table_get_values.arg.0", "GHashTable *,hash_table"},
	{"func.g_hash_table_get_values.args", "1"},
	{"func.g_hash_table_get_values.ret", "GList *"},
	{"func.g_hash_table_insert.arg.0", "GHashTable *,hash_table"},
	{"func.g_hash_table_insert.arg.1", "gpointer,key"},
	{"func.g_hash_table_insert.arg.2", "gpointer,value"},
	{"func.g_hash_table_insert.args", "3"},
	{"func.g_hash_table_insert.ret", "gboolean"},
	{"func.g_hash_table_lookup.arg.0", "GHashTable *,hash_table"},
	{"func.g_hash_table_lookup.arg.1", "gconstpointer,key"},
	{"func.g_hash_table_lookup.args", "2"},
	{"func.g_hash_table_lookup.ret", "gpointer"},
	{"func.g_hash_table_new_full.arg.0", "GHashFunc,hash_func"},
	{"func.g_hash_table_new_full.arg.1", "GEqualFunc,key_equal_func"},
	{"func.g_hash_table_new_full.arg.2", "GDestroyNotify,key_destroy_func"},
	{"func.g_hash_table_new_full.arg.3", "GDestroyNotify,value_destroy_func"},
	{"func.g_hash_table_new_full.args", "4"},
	{"func.g_hash_table_new_full.ret", "GHashTable *"},
	{"func.g_intern_static_string.arg.0", "const gchar *,string"},
	{"func.g_intern_static_string.args", "1"},
	{"func.g_intern_static_string.ret", "const gchar *"},
	{"func.g_intern_string.arg.0", "const gchar *,string"},
	{"func.g_intern_string.args", "1"},
	{"func.g_intern_string.ret", "const gchar *"},
	{"func.g_key_file_load_from_data.arg.0", "GKeyFile *,key_file"},
	{"func.g_key_file_load_from_data.arg.1", "const gchar *,data"},
	{"func.g_key_file_load_from_data.arg.2", "gsize,length"},
	{"func.g_key_file_load_from_data.arg.3", "GKeyFileFlags,flags"},
	{"func.g_key_file_load_from_data.arg.4", "GError **,error"},
	{"func.g_key_file_load_from_data.args", "5"},
	{"func.g_key_file_load_from_data.ret", "gboolean"},
	{"func.g_key_file_new.args", "0"},
	{"func.g_key_file_new.ret", "GKeyFile *"},
	{"func.g_key_file_unref.arg.0", "GKeyFile *,key_file"},
	{"func.g_key_file_unref.args", "1"},
	{"func.g_key_file_unref.ret", "void"},
	{"func.g_malloc.arg.0", "gsize,n_bytes"},
	{"func.g_malloc.args", "1"},
	{"func.g_malloc.ret", "gpointer"},
	{"func.g_malloc0.arg.0", "gsize,n_bytes"},
	{"func.g_malloc0.args", "1"},
	{"func.g_malloc0.ret", "gpointer"},
	{"func.g_malloc0_n.arg.0", "gsize,n_blocks"},
	{"func.g_malloc0_n.arg.1", "gsize,n_block_bytes"},
	{"func.g_malloc0_n.args", "2"},
	{"func.g_malloc0_n.ret", "gpointer"},
	{"func.g_malloc_n.arg.0", "gsize,n_blocks"},
	{"func.g_malloc_n.arg.1", "gsize,n_block_bytes"},
	{"func.g_malloc_n.args", "2"},
	{"func.g_malloc_n.ret", "gpointer"},
	{"func.g_memdup.arg.0", "gconstpointer,mem"},
	{"func.g_memdup.arg.1", "guint,byte_size"},
	{"func.g_memdup.args", "2"},
	{"func.g_memdup.ret", "gpointer"},
	{"func.g_memdup2.arg.0", "gconstpointer,mem"},
	{"func.g_memdup2.arg.1", "gsize,byte_size"},
	{"func.g_memdup2.args", "2"},
	{"func.g_memdup2.ret", "gpointer"},
	{"func.g_mkdir_with_parents.arg.0", "const gchar *,pathname"},
	{"func.g_mkdir_with_parents.arg.1", "gint,mode"},
	{"func.g_mkdir_with_parents.args", "2"},
	{"func.g_mkdir_with_parents.ret", "gint"},
	{"func.g_option_context_add_group.arg.0", "GOptionContext *,context"},
	{"func.g_option_context_add_group.arg.1", "GOptionGroup *,group"},
	{"func.g_option_context_add_group.args", "2"},
	{"func.g_option_context_add_group.ret", "void"},
	{"func.g_option_context_add_main_entries.arg.0", "GOptionContext *,context"},
	{"func.g_option_context_add_main_entries.arg.1", "const GOptionEntry *,entries"},
	{"func.g_option_context_add_main_entries.arg.2", "const gchar *,translation_domain"},
	{"func.g_option_context_add_main_entries.args", "3"},
	{"func.g_option_context_add_main_entries.ret", "void"},
	{"func.g_option_context_free.arg.0", "GOptionContext *,context"},
	{"func.g_option_context_free.args", "1"},
	{"func.g_option_context_free.ret", "void"},
	{"func.g_option_context_get_help.arg.0", "GOptionContext *,context"},
	{"func.g_option_context_get_help.arg.1", "gboolean,main_help"},
	{"func.g_option_context_get_help.arg.2", "GOptionGroup *,group"},
	{"func.g_option_context_get_help.args", "3"},
	{"func.g_option_context_get_help.ret", "gchar *"},
	{"func.g_option_context_new.arg.0", "const gchar *,parameter_string"},
	{"func.g_option_context_new.args", "1"},
	{"func.g_option_context_new.ret", "GOptionContext *"},
	{"func.g_option_context_parse.arg.0", "GOptionContext *,context"},
	{"func.g_option_context_parse.arg.1", "gint *,argc"},
	{"func.g_option_context_parse.arg.2", "gchar ***,argv"},
	{"func.g_option_context_parse.arg.3", "GError **,error"},
	{"func.g_option_context_parse.args", "4"},
	{"func.g_option_context_parse.ret", "gboolean"},
	{"func.g_option_context_set_help_enabled.arg.0", "GOptionContext *,context"},
	{"func.g_option_context_set_help_enabled.arg.1", "gboolean,help_enabled"},
	{"func.g_option_context_set_help_enabled.args", "2"},
	{"func.g_option_context_set_help_enabled.ret", "void"},
	{"func.g_option_context_set_summary.arg.0", "GOptionContext *,context"},
	{"func.g_option_context_set_summary.arg.1", "const gchar *,summary"},
	{"func.g_option_context_set_summary.args", "2"},
	{"func.g_option_context_set_summary.ret", "void"},
	{"func.g_option_group_add_entries.arg.0", "GOptionGroup *,group"},
	{"func.g_option_group_add_entries.arg.1", "const GOptionEntry *,entries"},
	{"func.g_option_group_add_entries.args", "2"},
	{"func.g_option_group_add_entries.ret", "void"},
	{"func.g_option_group_new.arg.0", "const gchar *,name"},
	{"func.g_option_group_new.arg.1", "const gchar *,description"},
	{"func.g_option_group_new.arg.2", "const gchar *,help_description"},
	{"func.g_option_group_new.arg.3", "gpointer,user_data"},
	{"func.g_option_group_new.arg.4", "GDestroyNotify,destroy"},
	{"func.g_option_group_new.args", "5"},
	{"func.g_option_group_new.ret", "GOptionGroup *"},
	{"func.g_path_get_basename.arg.0", "const gchar *,file_name"},
	{"func.g_path_get_basename.args", "1"},
	{"func.g_path_get_basename.ret", "gchar *"},
	{"func.g_path_get_dirname.arg.0", "const gchar *,file_name"},
	{"func.g_path_get_dirname.args", "1"},
	{"func.g_path_get_dirname.ret", "gchar *"},
	{"func.g_path_is_absolute.arg.0", "const gchar *,file_name"},
	{"func.g_path_is_absolute.args", "1"},
	{"func.g_path_is_absolute.ret", "gboolean"},
	{"func.g_path_skip_root.arg.0", "const gchar *,file_name"},
	{"func.g_path_skip_root.args", "1"},
	{"func.g_path_skip_root.ret", "const gchar *"},
	{"func.g_prefix_error.arg.0", "GError **,err"},
	{"func.g_prefix_error.arg.1", "const gchar *,format"},
	{"func.g_prefix_error.arg.2", ",..."},
	{"func.g_prefix_error.args", "3"},
	{"func.g_prefix_error.ret", "void"},
	{"func.g_prefix_error_literal.arg.0", "GError **,err"},
	{"func.g_prefix_error_literal.arg.1", "const gchar *,prefix"},
	{"func.g_prefix_error_literal.args", "2"},
	{"func.g_prefix_error_literal.ret", "void"},
	{"func.g_print.arg.0", "const gchar *,format"},
	{"func.g_print.arg.1", ",..."},
	{"func.g_print.args", "2"},
	{"func.g_print.ret", "void"},
	{"func.g_printerr.arg.0", "const gchar *,format"},
	{"func.g_printerr.arg.1", ",..."},
	{"func.g_printerr.args", "2"},
	{"func.g_printerr.ret", "void"},
	{"func.g_propagate_error.arg.0", "GError **,dest"},
	{"func.g_propagate_error.arg.1", "GError *,src"},
	{"func.g_propagate_error.args", "2"},
	{"func.g_propagate_error.ret", "void"},
	{"func.g_propagate_prefixed_error.arg.0", "GError **,dest"},
	{"func.g_propagate_prefixed_error.arg.1", "GError *,src"},
	{"func.g_propagate_prefixed_error.arg.2", "const gchar *,format"},
	{"func.g_propagate_prefixed_error.arg.3", ",..."},
	{"func.g_propagate_prefixed_error.args", "4"},
	{"func.g_propagate_prefixed_error.ret", "void"},
	{"func.g_ptr_array_add.arg.0", "GPtrArray *,array"},
	{"func.g_ptr_array_add.arg.1", "gpointer,data"},
	{"func.g_ptr_array_add.args", "2"},
	{"func.g_ptr_array_add.ret", "void"},
	{"func.g_ptr_array_free.arg.0", "GPtrArray *,array"},
	{"func.g_ptr_array_free.arg.1", "gboolean,free_segment"},
	{"func.g_ptr_array_free.args", "2"},
	{"func.g_ptr_array_free.ret", "gpointer *"},
	{"func.g_ptr_array_new_with_free_func.arg.0", "GDestroyNotify,element_free_func"},
	{"func.g_ptr_array_new_with_free_func.args", "1"},
	{"func.g_ptr_array_new_with_free_func.ret", "GPtrArray *"},
	{"func.g_ptr_array_ref.arg.0", "GPtrArray *,array"},
	{"func.g_ptr_array_ref.args", "1"},
	{"func.g_ptr_array_ref.ret", "GPtrArray *"},
	{"func.g_ptr_array_sort.arg.0", "GPtrArray *,array"},
	{"func.g_ptr_array_sort.arg.1", "GCompareFunc,compare_func"},
	{"func.g_ptr_array_sort.args", "2"},
	{"func.g_ptr_array_sort.ret", "void"},
	{"func.g_ptr_array_unref.arg.0", "GPtrArray *,array"},
	{"func.g_ptr_array_unref.args", "1"},
	{"func.g_ptr_array_unref.ret", "void"},
	{"func.g_quark_from_static_string.arg.0", "const gchar *,string"},
	{"func.g_quark_from_static_string.args", "1"},
	{"func.g_quark_from_static_string.ret", "GQuark"},
	{"func.g_quark_from_string.arg.0", "const gchar *,string"},
	{"func.g_quark_from_string.args", "1"},
	{"func.g_quark_from_string.ret", "GQuark"},
	{"func.g_quark_to_string.arg.0", "GQuark,quark"},
	{"func.g_quark_to_string.args", "1"},
	{"func.g_quark_to_string.ret", "const gchar *"},
	{"func.g_quark_try_string.arg.0", "const gchar *,string"},
	{"func.g_quark_try_string.args", "1"},
	{"func.g_quark_try_string.ret", "GQuark"},
	{"func.g_realloc.arg.0", "gpointer,mem"},
	{"func.g_realloc.arg.1", "gsize,n_bytes"},
	{"func.g_realloc.args", "2"},
	{"func.g_realloc.ret", "gpointer"},
	{"func.g_realloc_n.arg.0", "gpointer,mem"},
	{"func.g_realloc_n.arg.1", "gsize,n_blocks"},
	{"func.g_realloc_n.arg.2", "gsize,n_block_bytes"},
	{"func.g_realloc_n.args", "3"},
	{"func.g_realloc_n.ret", "gpointer"},
	{"func.g_set_error.arg.0", "GError **,err"},
	{"func.g_set_error.arg.1", "GQuark,domain"},
	{"func.g_set_error.arg.2", "gint,code"},
	{"func.g_set_error.arg.3", "const gchar *,format"},
	{"func.g_set_error.arg.4", ",..."},
	{"func.g_set_error.args", "5"},
	{"func.g_set_error.ret", "void"},
	{"func.g_set_error_literal.arg.0", "GError **,err"},
	{"func.g_set_error_literal.arg.1", "GQuark,domain"},
	{"func.g_set_error_literal.arg.2", "gint,code"},
	{"func.g_set_error_literal.arg.3", "const gchar *,message"},
	{"func.g_set_error_literal.args", "4"},
	{"func.g_set_error_literal.ret", "void"},
	{"func.g_set_prgname.arg.0", "const gchar *,prgname"},
	{"func.g_set_prgname.args", "1"},
	{"func.g_set_prgname.ret", "void"},
	{"func.g_set_printerr_handler.arg.0", "GPrintFunc,func"},
	{"func.g_set_printerr_handler.args", "1"},
	{"func.g_set_printerr_handler.ret", "GPrintFunc"},
	{"func.g_setenv.arg.0", "const gchar *,variable"},
	{"func.g_setenv.arg.1", "const gchar *,value"},
	{"func.g_setenv.arg.2", "gboolean,overwrite"},
	{"func.g_setenv.args", "3"},
	{"func.g_setenv.ret", "gboolean"},
	{"func.g_shell_error_quark.args", "0"},
	{"func.g_shell_error_quark.ret", "GQuark"},
	{"func.g_shell_parse_argv.arg.0", "const gchar *,command_line"},
	{"func.g_shell_parse_argv.arg.1", "gint *,argcp"},
	{"func.g_shell_parse_argv.arg.2", "gchar ***,argvp"},
	{"func.g_shell_parse_argv.arg.3", "GError **,error"},
	{"func.g_shell_parse_argv.args", "4"},
	{"func.g_shell_parse_argv.ret", "gboolean"},
	{"func.g_shell_quote.arg.0", "const gchar *,unquoted_string"},
	{"func.g_shell_quote.args", "1"},
	{"func.g_shell_quote.ret", "gchar *"},
	{"func.g_shell_unquote.arg.0", "const gchar *,quoted_string"},
	{"func.g_shell_unquote.arg.1", "GError **,error"},
	{"func.g_shell_unquote.args", "2"},
	{"func.g_shell_unquote.ret", "gchar *"},
	{"func.g_stpcpy.arg.0", "gchar *,dest"},
	{"func.g_stpcpy.arg.1", "const char *,src"},
	{"func.g_stpcpy.args", "2"},
	{"func.g_stpcpy.ret", "gchar *"},
	{"func.g_str_equal.arg.0", "gconstpointer,v1"},
	{"func.g_str_equal.arg.1", "gconstpointer,v2"},
	{"func.g_str_equal.args", "2"},
	{"func.g_str_equal.ret", "gboolean"},
	{"func.g_str_has_prefix.arg.0", "const gchar *,str"},
	{"func.g_str_has_prefix.arg.1", "const gchar *,prefix"},
	{"func.g_str_has_prefix.args", "2"},
	{"func.g_str_has_prefix.ret", "gboolean"},
	{"func.g_str_has_suffix.arg.0", "const gchar *,str"},
	{"func.g_str_has_suffix.arg.1", "const gchar *,suffix"},
	{"func.g_str_has_suffix.args", "2"},
	{"func.g_str_has_suffix.ret", "gboolean"},
	{"func.g_str_hash.arg.0", "gconstpointer,v"},
	{"func.g_str_hash.args", "1"},
	{"func.g_str_hash.ret", "guint"},
	{"func.g_str_is_ascii.arg.0", "const gchar *,str"},
	{"func.g_str_is_ascii.args", "1"},
	{"func.g_str_is_ascii.ret", "gboolean"},
	{"func.g_str_match_string.arg.0", "const gchar *,search_term"},
	{"func.g_str_match_string.arg.1", "const gchar *,potential_hit"},
	{"func.g_str_match_string.arg.2", "gboolean,accept_alternates"},
	{"func.g_str_match_string.args", "3"},
	{"func.g_str_match_string.ret", "gboolean"},
	{"func.g_str_to_ascii.arg.0", "const gchar *,str"},
	{"func.g_str_to_ascii.arg.1", "const gchar *,from_locale"},
	{"func.g_str_to_ascii.args", "2"},
	{"func.g_str_to_ascii.ret", "gchar *"},
	{"func.g_str_tokenize_and_fold.arg.0", "const gchar *,string"},
	{"func.g_str_tokenize_and_fold.arg.1", "const gchar *,translit_locale"},
	{"func.g_str_tokenize_and_fold.arg.2", "gchar ***,ascii_alternates"},
	{"func.g_str_tokenize_and_fold.args", "3"},
	{"func.g_str_tokenize_and_fold.ret", "gchar **"},
	{"func.g_strcanon.arg.0", "gchar *,string"},
	{"func.g_strcanon.arg.1", "const gchar *,valid_chars"},
	{"func.g_strcanon.arg.2", "gchar,substitutor"},
	{"func.g_strcanon.args", "3"},
	{"func.g_strcanon.ret", "gchar *"},
	{"func.g_strcasecmp.arg.0", "const gchar *,s1"},
	{"func.g_strcasecmp.arg.1", "const gchar *,s2"},
	{"func.g_strcasecmp.args", "2"},
	{"func.g_strcasecmp.ret", "gint"},
	{"func.g_strchomp.arg.0", "gchar *,string"},
	{"func.g_strchomp.args", "1"},
	{"func.g_strchomp.ret", "gchar *"},
	{"func.g_strchug.arg.0", "gchar *,string"},
	{"func.g_strchug.args", "1"},
	{"func.g_strchug.ret", "gchar *"},
	{"func.g_strcmp0.arg.0", "const char *,str1"},
	{"func.g_strcmp0.arg.1", "const char *,str2"},
	{"func.g_strcmp0.args", "2"},
	{"func.g_strcmp0.ret", "int"},
	{"func.g_strcompress.arg.0", "const gchar *,source"},
	{"func.g_strcompress.args", "1"},
	{"func.g_strcompress.ret", "gchar *"},
	{"func.g_strconcat.arg.0", "const gchar *,string1"},
	{"func.g_strconcat.arg.1", ",..."},
	{"func.g_strconcat.args", "2"},
	{"func.g_strconcat.ret", "gchar *"},
	{"func.g_strdelimit.arg.0", "gchar *,string"},
	{"func.g_strdelimit.arg.1", "const gchar *,delimiters"},
	{"func.g_strdelimit.arg.2", "gchar,new_delimiter"},
	{"func.g_strdelimit.args", "3"},
	{"func.g_strdelimit.ret", "gchar *"},
	{"func.g_strdown.arg.0", "gchar *,string"},
	{"func.g_strdown.args", "1"},
	{"func.g_strdown.ret", "gchar *"},
	{"func.g_strdup.arg.0", "const gchar *,str"},
	{"func.g_strdup.args", "1"},
	{"func.g_strdup.ret", "gchar *"},
	{"func.g_strdup_printf.arg.0", "const gchar *,format"},
	{"func.g_strdup_printf.arg.1", ",..."},
	{"func.g_strdup_printf.args", "2"},
	{"func.g_strdup_printf.ret", "gchar *"},
	{"func.g_strdup_vprintf.arg.0", "const gchar *,format"},
	{"func.g_strdup_vprintf.arg.1", "va_list,args"},
	{"func.g_strdup_vprintf.args", "2"},
	{"func.g_strdup_vprintf.ret", "gchar *"},
	{"func.g_strdupv.arg.0", "gchar **,str_array"},
	{"func.g_strdupv.args", "1"},
	{"func.g_strdupv.ret", "gchar **"},
	{"func.g_strerror.arg.0", "gint,errnum"},
	{"func.g_strerror.args", "1"},
	{"func.g_strerror.ret", "const gchar *"},
	{"func.g_strescape.arg.0", "const gchar *,source"},
	{"func.g_strescape.arg.1", "const gchar *,exceptions"},
	{"func.g_strescape.args", "2"},
	{"func.g_strescape.ret", "gchar *"},
	{"func.g_strfreev.arg.0", "gchar **,str_array"},
	{"func.g_strfreev.args", "1"},
	{"func.g_strfreev.ret", "void"},
	{"func.g_string_append.arg.0", "GString *,string"},
	{"func.g_string_append.arg.1", "const gchar *,val"},
	{"func.g_string_append.args", "2"},
	{"func.g_string_append.ret", "GString *"},
	{"func.g_string_append_c.arg.0", "GString *,string"},
	{"func.g_string_append_c.arg.1", "gchar,c"},
	{"func.g_string_append_c.args", "2"},
	{"func.g_string_append_c.ret", "GString *"},
	{"func.g_string_append_len.arg.0", "GString *,string"},
	{"func.g_string_append_len.arg.1", "const gchar *,val"},
	{"func.g_string_append_len.arg.2", "gssize,len"},
	{"func.g_string_append_len.args", "3"},
	{"func.g_string_append_len.ret", "GString *"},
	{"func.g_string_append_printf.arg.0", "GString *,string"},
	{"func.g_string_append_printf.arg.1", "const gchar *,format"},
	{"func.g_string_append_printf.arg.2", ",..."},
	{"func.g_string_append_printf.args", "3"},
	{"func.g_string_append_printf.ret", "void"},
	{"func.g_string_append_unichar.arg.0", "GString *,string"},
	{"func.g_string_append_unichar.arg.1", "gunichar,wc"},
	{"func.g_string_append_unichar.args", "2"},
	{"func.g_string_append_unichar.ret", "GString *"},
	{"func.g_string_append_uri_escaped.arg.0", "GString *,string"},
	{"func.g_string_append_uri_escaped.arg.1", "const gchar *,unescaped"},
	{"func.g_string_append_uri_escaped.arg.2", "const gchar *,reserved_chars_allowed"},
	{"func.g_string_append_uri_escaped.arg.3", "gboolean,allow_utf8"},
	{"func.g_string_append_uri_escaped.args", "4"},
	{"func.g_string_append_uri_escaped.ret", "GString *"},
	{"func.g_string_append_vprintf.arg.0", "GString *,string"},
	{"func.g_string_append_vprintf.arg.1", "const gchar *,format"},
	{"func.g_string_append_vprintf.arg.2", "va_list,args"},
	{"func.g_string_append_vprintf.args", "3"},
	{"func.g_string_append_vprintf.ret", "void"},
	{"func.g_string_ascii_down.arg.0", "GString *,string"},
	{"func.g_string_ascii_down.args", "1"},
	{"func.g_string_ascii_down.ret", "GString *"},
	{"func.g_string_ascii_up.arg.0", "GString *,string"},
	{"func.g_string_ascii_up.args", "1"},
	{"func.g_string_ascii_up.ret", "GString *"},
	{"func.g_string_assign.arg.0", "GString *,string"},
	{"func.g_string_assign.arg.1", "const gchar *,rval"},
	{"func.g_string_assign.args", "2"},
	{"func.g_string_assign.ret", "GString *"},
	{"func.g_string_chunk_clear.arg.0", "GStringChunk *,chunk"},
	{"func.g_string_chunk_clear.args", "1"},
	{"func.g_string_chunk_clear.ret", "void"},
	{"func.g_string_chunk_free.arg.0", "GStringChunk *,chunk"},
	{"func.g_string_chunk_free.args", "1"},
	{"func.g_string_chunk_free.ret", "void"},
	{"func.g_string_chunk_insert.arg.0", "GStringChunk *,chunk"},
	{"func.g_string_chunk_insert.arg.1", "const gchar *,string"},
	{"func.g_string_chunk_insert.args", "2"},
	{"func.g_string_chunk_insert.ret", "gchar *"},
	{"func.g_string_chunk_insert_const.arg.0", "GStringChunk *,chunk"},
	{"func.g_string_chunk_insert_const.arg.1", "const gchar *,string"},
	{"func.g_string_chunk_insert_const.args", "2"},
	{"func.g_string_chunk_insert_const.ret", "gchar *"},
	{"func.g_string_chunk_insert_len.arg.0", "GStringChunk *,chunk"},
	{"func.g_string_chunk_insert_len.arg.1", "const gchar *,string"},
	{"func.g_string_chunk_insert_len.arg.2", "gssize,len"},
	{"func.g_string_chunk_insert_len.args", "3"},
	{"func.g_string_chunk_insert_len.ret", "gchar *"},
	{"func.g_string_chunk_new.arg.0", "gsize,size"},
	{"func.g_string_chunk_new.args", "1"},
	{"func.g_string_chunk_new.ret", "GStringChunk *"},
	{"func.g_string_copy.arg.0", "GString *,string"},
	{"func.g_string_copy.args", "1"},
	{"func.g_string_copy.ret", "GString *"},
	{"func.g_string_down.arg.0", "GString *,string"},
	{"func.g_string_down.args", "1"},
	{"func.g_string_down.ret", "GString *"},
	{"func.g_string_equal.arg.0", "const GString *,v"},
	{"func.g_string_equal.arg.1", "const GString *,v2"},
	{"func.g_string_equal.args", "2"},
	{"func.g_string_equal.ret", "gboolean"},
	{"func.g_string_erase.arg.0", "GString *,string"},
	{"func.g_string_erase.arg.1", "gssize,pos"},
	{"func.g_string_erase.arg.2", "gssize,len"},
	{"func.g_string_erase.args", "3"},
	{"func.g_string_erase.ret", "GString *"},
	{"func.g_string_free.arg.0", "GString *,string"},
	{"func.g_string_free.arg.1", "gboolean,free_segment"},
	{"func.g_string_free.args", "2"},
	{"func.g_string_free.ret", "gchar *"},
	{"func.g_string_free_and_steal.arg.0", "GString *,string"},
	{"func.g_string_free_and_steal.args", "1"},
	{"func.g_string_free_and_steal.ret", "gchar *"},
	{"func.g_string_free_deep.arg.0", "GString *,string"},
	{"func.g_string_free_deep.args", "1"},
	{"func.g_string_free_deep.ret", "void"},
	{"func.g_string_free_to_bytes.arg.0", "GString *,string"},
	{"func.g_string_free_to_bytes.args", "1"},
	{"func.g_string_free_to_bytes.ret", "GBytes *"},
	{"func.g_string_hash.arg.0", "const GString *,str"},
	{"func.g_string_hash.args", "1"},
	{"func.g_string_hash.ret", "guint"},
	{"func.g_string_insert.arg.0", "GString *,string"},
	{"func.g_string_insert.arg.1", "gssize,pos"},
	{"func.g_string_insert.arg.2", "const gchar *,val"},
	{"func.g_string_insert.args", "3"},
	{"func.g_string_insert.ret", "GString *"},
	{"func.g_string_insert_c.arg.0", "GString *,string"},
	{"func.g_string_insert_c.arg.1", "gssize,pos"},
	{"func.g_string_insert_c.arg.2", "gchar,c"},
	{"func.g_string_insert_c.args", "3"},
	{"func.g_string_insert_c.ret", "GString *"},
	{"func.g_string_insert_len.arg.0", "GString *,string"},
	{"func.g_string_insert_len.arg.1", "gssize,pos"},
	{"func.g_string_insert_len.arg.2", "const gchar *,val"},
	{"func.g_string_insert_len.arg.3", "gssize,len"},
	{"func.g_string_insert_len.args", "4"},
	{"func.g_string_insert_len.ret", "GString *"},
	{"func.g_string_insert_unichar.arg.0", "GString *,string"},
	{"func.g_string_insert_unichar.arg.1", "gssize,pos"},
	{"func.g_string_insert_unichar.arg.2", "gunichar,wc"},
	{"func.g_string_insert_unichar.args", "3"},
	{"func.g_string_insert_unichar.ret", "GString *"},
	{"func.g_string_new.arg.0", "const gchar *,init"},
	{"func.g_string_new.args", "1"},
	{"func.g_string_new.ret", "GString *"},
	{"func.g_string_new_len.arg.0", "const gchar *,init"},
	{"func.g_string_new_len.arg.1", "gssize,len"},
	{"func.g_string_new_len.args", "2"},
	{"func.g_string_new_len.ret", "GString *"},
	{"func.g_string_new_take.arg.0", "gchar *,init"},
	{"func.g_string_new_take.args", "1"},
	{"func.g_string_new_take.ret", "GString *"},
	{"func.g_string_overwrite.arg.0", "GString *,string"},
	{"func.g_string_overwrite.arg.1", "gsize,pos"},
	{"func.g_string_overwrite.arg.2", "const gchar *,val"},
	{"func.g_string_overwrite.args", "3"},
	{"func.g_string_overwrite.ret", "GString *"},
	{"func.g_string_overwrite_len.arg.0", "GString *,string"},
	{"func.g_string_overwrite_len.arg.1", "gsize,pos"},
	{"func.g_string_overwrite_len.arg.2", "const gchar *,val"},
	{"func.g_string_overwrite_len.arg.3", "gssize,len"},
	{"func.g_string_overwrite_len.args", "4"},
	{"func.g_string_overwrite_len.ret", "GString *"},
	{"func.g_string_prepend.arg.0", "GString *,string"},
	{"func.g_string_prepend.arg.1", "const gchar *,val"},
	{"func.g_string_prepend.args", "2"},
	{"func.g_string_prepend.ret", "GString *"},
	{"func.g_string_prepend_c.arg.0", "GString *,string"},
	{"func.g_string_prepend_c.arg.1", "gchar,c"},
	{"func.g_string_prepend_c.args", "2"},
	{"func.g_string_prepend_c.ret", "GString *"},
	{"func.g_string_prepend_len.arg.0", "GString *,string"},
	{"func.g_string_prepend_len.arg.1", "const gchar *,val"},
	{"func.g_string_prepend_len.arg.2", "gssize,len"},
	{"func.g_string_prepend_len.args", "3"},
	{"func.g_string_prepend_len.ret", "GString *"},
	{"func.g_string_prepend_unichar.arg.0", "GString *,string"},
	{"func.g_string_prepend_unichar.arg.1", "gunichar,wc"},
	{"func.g_string_prepend_unichar.args", "2"},
	{"func.g_string_prepend_unichar.ret", "GString *"},
	{"func.g_string_printf.arg.0", "GString *,string"},
	{"func.g_string_printf.arg.1", "const gchar *,format"},
	{"func.g_string_printf.arg.2", ",..."},
	{"func.g_string_printf.args", "3"},
	{"func.g_string_printf.ret", "void"},
	{"func.g_string_replace.arg.0", "GString *,string"},
	{"func.g_string_replace.arg.1", "const gchar *,find"},
	{"func.g_string_replace.arg.2", "const gchar *,replace"},
	{"func.g_string_replace.arg.3", "guint,limit"},
	{"func.g_string_replace.args", "4"},
	{"func.g_string_replace.ret", "guint"},
	{"func.g_string_set_size.arg.0", "GString *,string"},
	{"func.g_string_set_size.arg.1", "gsize,len"},
	{"func.g_string_set_size.args", "2"},
	{"func.g_string_set_size.ret", "GString *"},
	{"func.g_string_sized_new.arg.0", "gsize,dfl_size"},
	{"func.g_string_sized_new.args", "1"},
	{"func.g_string_sized_new.ret", "GString *"},
	{"func.g_string_truncate.arg.0", "GString *,string"},
	{"func.g_string_truncate.arg.1", "gsize,len"},
	{"func.g_string_truncate.args", "2"},
	{"func.g_string_truncate.ret", "GString *"},
	{"func.g_string_up.arg.0", "GString *,string"},
	{"func.g_string_up.args", "1"},
	{"func.g_string_up.ret", "GString *"},
	{"func.g_string_vprintf.arg.0", "GString *,string"},
	{"func.g_string_vprintf.arg.1", "const gchar *,format"},
	{"func.g_string_vprintf.arg.2", "va_list,args"},
	{"func.g_string_vprintf.args", "3"},
	{"func.g_string_vprintf.ret", "void"},
	{"func.g_strip_context.arg.0", "const gchar *,msgid"},
	{"func.g_strip_context.arg.1", "const gchar *,msgval"},
	{"func.g_strip_context.args", "2"},
	{"func.g_strip_context.ret", "const gchar *"},
	{"func.g_strjoin.arg.0", "const gchar *,separator"},
	{"func.g_strjoin.arg.1", ",..."},
	{"func.g_strjoin.args", "2"},
	{"func.g_strjoin.ret", "gchar *"},
	{"func.g_strjoinv.arg.0", "const gchar *,separator"},
	{"func.g_strjoinv.arg.1", "gchar **,str_array"},
	{"func.g_strjoinv.args", "2"},
	{"func.g_strjoinv.ret", "gchar *"},
	{"func.g_strlcat.arg.0", "gchar *,dest"},
	{"func.g_strlcat.arg.1", "const gchar *,src"},
	{"func.g_strlcat.arg.2", "gsize,dest_size"},
	{"func.g_strlcat.args", "3"},
	{"func.g_strlcat.ret", "gsize"},
	{"func.g_strlcpy.arg.0", "gchar *,dest"},
	{"func.g_strlcpy.arg.1", "const gchar *,src"},
	{"func.g_strlcpy.arg.2", "gsize,dest_size"},
	{"func.g_strlcpy.args", "3"},
	{"func.g_strlcpy.ret", "gsize"},
	{"func.g_strncasecmp.arg.0", "const gchar *,s1"},
	{"func.g_strncasecmp.arg.1", "const gchar *,s2"},
	{"func.g_strncasecmp.arg.2", "guint,n"},
	{"func.g_strncasecmp.args", "3"},
	{"func.g_strncasecmp.ret", "gint"},
	{"func.g_strndup.arg.0", "const gchar *,str"},
	{"func.g_strndup.arg.1", "gsize,n"},
	{"func.g_strndup.args", "2"},
	{"func.g_strndup.ret", "gchar *"},
	{"func.g_strnfill.arg.0", "gsize,length"},
	{"func.g_strnfill.arg.1", "gchar,fill_char"},
	{"func.g_strnfill.args", "2"},
	{"func.g_strnfill.ret", "gchar *"},
	{"func.g_strreverse.arg.0", "gchar *,string"},
	{"func.g_strreverse.args", "1"},
	{"func.g_strreverse.ret", "gchar *"},
	{"func.g_strrstr.arg.0", "const gchar *,haystack"},
	{"func.g_strrstr.arg.1", "const gchar *,needle"},
	{"func.g_strrstr.args", "2"},
	{"func.g_strrstr.ret", "gchar *"},
	{"func.g_strrstr_len.arg.0", "const gchar *,haystack"},
	{"func.g_strrstr_len.arg.1", "gssize,haystack_len"},
	{"func.g_strrstr_len.arg.2", "const gchar *,needle"},
	{"func.g_strrstr_len.args", "3"},
	{"func.g_strrstr_len.ret", "gchar *"},
	{"func.g_strsignal.arg.0", "gint,signum"},
	{"func.g_strsignal.args", "1"},
	{"func.g_strsignal.ret", "const gchar *"},
	{"func.g_strsplit.arg.0", "const gchar *,string"},
	{"func.g_strsplit.arg.1", "const gchar *,delimiter"},
	{"func.g_strsplit.arg.2", "gint,max_tokens"},
	{"func.g_strsplit.args", "3"},
	{"func.g_strsplit.ret", "gchar **"},
	{"func.g_strsplit_set.arg.0", "const gchar *,string"},
	{"func.g_strsplit_set.arg.1", "const gchar *,delimiters"},
	{"func.g_strsplit_set.arg.2", "gint,max_tokens"},
	{"func.g_strsplit_set.args", "3"},
	{"func.g_strsplit_set.ret", "gchar **"},
	{"func.g_strstr_len.arg.0", "const gchar *,haystack"},
	{"func.g_strstr_len.arg.1", "gssize,haystack_len"},
	{"func.g_strstr_len.arg.2", "const gchar *,needle"},
	{"func.g_strstr_len.args", "3"},
	{"func.g_strstr_len.ret", "gchar *"},
	{"func.g_strtod.arg.0", "const gchar *,nptr"},
	{"func.g_strtod.arg.1", "gchar **,endptr"},
	{"func.g_strtod.args", "2"},
	{"func.g_strtod.ret", "gdouble"},
	{"func.g_strup.arg.0", "gchar *,string"},
	{"func.g_strup.args", "1"},
	{"func.g_strup.ret", "gchar *"},
	{"func.g_strv_contains.arg.0", "const gchar * const *,strv"},
	{"func.g_strv_contains.arg.1", "const gchar *,str"},
	{"func.g_strv_contains.args", "2"},
	{"func.g_strv_contains.ret", "gboolean"},
	{"func.g_strv_equal.arg.0", "const gchar * const *,strv1"},
	{"func.g_strv_equal.arg.1", "const gchar * const *,strv2"},
	{"func.g_strv_equal.args", "2"},
	{"func.g_strv_equal.ret", "gboolean"},
	{"func.g_strv_length.arg.0", "gchar **,str_array"},
	{"func.g_strv_length.args", "1"},
	{"func.g_strv_length.ret", "guint"},
	{"func.g_try_malloc.arg.0", "gsize,n_bytes"},
	{"func.g_try_malloc.args", "1"},
	{"func.g_try_malloc.ret", "gpointer"},
	{"func.g_try_malloc0.arg.0", "gsize,n_bytes"},
	{"func.g_try_malloc0.args", "1"},
	{"func.g_try_malloc0.ret", "gpointer"},
	{"func.g_try_malloc0_n.arg.0", "gsize,n_blocks"},
	{"func.g_try_malloc0_n.arg.1", "gsize,n_block_bytes"},
	{"func.g_try_malloc0_n.args", "2"},
	{"func.g_try_malloc0_n.ret", "gpointer"},
	{"func.g_try_malloc_n.arg.0", "gsize,n_blocks"},
	{"func.g_try_malloc_n.arg.1", "gsize,n_block_bytes"},
	{"func.g_try_malloc_n.args", "2"},
	{"func.g_try_malloc_n.ret", "gpointer"},
	{"func.g_try_realloc.arg.0", "gpointer,mem"},
	{"func.g_try_realloc.arg.1", "gsize,n_bytes"},
	{"func.g_try_realloc.args", "2"},
	{"func.g_try_realloc.ret", "gpointer"},
	{"func.g_try_realloc_n.arg.0", "gpointer,mem"},
	{"func.g_try_realloc_n.arg.1", "gsize,n_blocks"},
	{"func.g_try_realloc_n.arg.2", "gsize,n_block_bytes"},
	{"func.g_try_realloc_n.args", "3"},
	{"func.g_try_realloc_n.ret", "gpointer"},
	{"func.g_ucs4_to_utf16.arg.0", "const gunichar *,str"},
	{"func.g_ucs4_to_utf16.arg.1", "glong,len"},
	{"func.g_ucs4_to_utf16.arg.2", "glong *,items_read"},
	{"func.g_ucs4_to_utf16.arg.3", "glong *,items_written"},
	{"func.g_ucs4_to_utf16.arg.4", "GError **,error"},
	{"func.g_ucs4_to_utf16.args", "5"},
	{"func.g_ucs4_to_utf16.ret", "gunichar2 *"},
	{"func.g_ucs4_to_utf8.arg.0", "const gunichar *,str"},
	{"func.g_ucs4_to_utf8.arg.1", "glong,len"},
	{"func.g_ucs4_to_utf8.arg.2", "glong *,items_read"},
	{"func.g_ucs4_to_utf8.arg.3", "glong *,items_written"},
	{"func.g_ucs4_to_utf8.arg.4", "GError **,error"},
	{"func.g_ucs4_to_utf8.args", "5"},
	{"func.g_ucs4_to_utf8.ret", "gchar *"},
	{"func.g_unichar_to_utf8.arg.0", "gunichar,c"},
	{"func.g_unichar_to_utf8.arg.1", "gchar *,outbuf"},
	{"func.g_unichar_to_utf8.args", "2"},
	{"func.g_unichar_to_utf8.ret", "gint"},
	{"func.g_unsetenv.arg.0", "const gchar *,variable"},
	{"func.g_unsetenv.args", "1"},
	{"func.g_unsetenv.ret", "void"},
	{"func.g_utf16_to_ucs4.arg.0", "const gunichar2 *,str"},
	{"func.g_utf16_to_ucs4.arg.1", "glong,len"},
	{"func.g_utf16_to_ucs4.arg.2", "glong *,items_read"},
	{"func.g_utf16_to_ucs4.arg.3", "glong *,items_written"},
	{"func.g_utf16_to_ucs4.arg.4", "GError **,error"},
	{"func.g_utf16_to_ucs4.args", "5"},
	{"func.g_utf16_to_ucs4.ret", "gunichar *"},
	{"func.g_utf16_to_utf8.arg.0", "const gunichar2 *,str"},
	{"func.g_utf16_to_utf8.arg.1", "glong,len"},
	{"func.g_utf16_to_utf8.arg.2", "glong *,items_read"},
	{"func.g_utf16_to_utf8.arg.3", "glong *,items_written"},
	{"func.g_utf16_to_utf8.arg.4", "GError **,error"},
	{"func.g_utf16_to_utf8.args", "5"},
	{"func.g_utf16_to_utf8.ret", "gchar *"},
	{"func.g_utf8_casefold.arg.0", "const gchar *,str"},
	{"func.g_utf8_casefold.arg.1", "gssize,len"},
	{"func.g_utf8_casefold.args", "2"},
	{"func.g_utf8_casefold.ret", "gchar *"},
	{"func.g_utf8_collate.arg.0", "const gchar *,str1"},
	{"func.g_utf8_collate.arg.1", "const gchar *,str2"},
	{"func.g_utf8_collate.args", "2"},
	{"func.g_utf8_collate.ret", "gint"},
	{"func.g_utf8_collate_key.arg.0", "const gchar *,str"},
	{"func.g_utf8_collate_key.arg.1", "gssize,len"},
	{"func.g_utf8_collate_key.args", "2"},
	{"func.g_utf8_collate_key.ret", "gchar *"},
	{"func.g_utf8_collate_key_for_filename.arg.0", "const gchar *,str"},
	{"func.g_utf8_collate_key_for_filename.arg.1", "gssize,len"},
	{"func.g_utf8_collate_key_for_filename.args", "2"},
	{"func.g_utf8_collate_key_for_filename.ret", "gchar *"},
	{"func.g_utf8_find_next_char.arg.0", "const gchar *,p"},
	{"func.g_utf8_find_next_char.arg.1", "const gchar *,end"},
	{"func.g_utf8_find_next_char.args", "2"},
	{"func.g_utf8_find_next_char.ret", "gchar *"},
	{"func.g_utf8_find_prev_char.arg.0", "const gchar *,str"},
	{"func.g_utf8_find_prev_char.arg.1", "const gchar *,p"},
	{"func.g_utf8_find_prev_char.args", "2"},
	{"func.g_utf8_find_prev_char.ret", "gchar *"},
	{"func.g_utf8_get_char.arg.0", "const gchar *,p"},
	{"func.g_utf8_get_char.args", "1"},
	{"func.g_utf8_get_char.ret", "gunichar"},
	{"func.g_utf8_get_char_validated.arg.0", "const gchar *,p"},
	{"func.g_utf8_get_char_validated.arg.1", "gssize,max_len"},
	{"func.g_utf8_get_char_validated.args", "2"},
	{"func.g_utf8_get_char_validated.ret", "gunichar"},
	{"func.g_utf8_make_valid.arg.0", "const gchar *,str"},
	{"func.g_utf8_make_valid.arg.1", "gssize,len"},
	{"func.g_utf8_make_valid.args", "2"},
	{"func.g_utf8_make_valid.ret", "gchar *"},
	{"func.g_utf8_normalize.arg.0", "const gchar *,str"},
	{"func.g_utf8_normalize.arg.1", "gssize,len"},
	{"func.g_utf8_normalize.arg.2", "GNormalizeMode,mode"},
	{"func.g_utf8_normalize.args", "3"},
	{"func.g_utf8_normalize.ret", "gchar *"},
	{"func.g_utf8_offset_to_pointer.arg.0", "const gchar *,str"},
	{"func.g_utf8_offset_to_pointer.arg.1", "glong,offset"},
	{"func.g_utf8_offset_to_pointer.args", "2"},
	{"func.g_utf8_offset_to_pointer.ret", "gchar *"},
	{"func.g_utf8_pointer_to_offset.arg.0", "const gchar *,str"},
	{"func.g_utf8_pointer_to_offset.arg.1", "const gchar *,pos"},
	{"func.g_utf8_pointer_to_offset.args", "2"},
	{"func.g_utf8_pointer_to_offset.ret", "glong"},
	{"func.g_utf8_prev_char.arg.0", "const gchar *,p"},
	{"func.g_utf8_prev_char.args", "1"},
	{"func.g_utf8_prev_char.ret", "gchar *"},
	{"func.g_utf8_strchr.arg.0", "const gchar *,p"},
	{"func.g_utf8_strchr.arg.1", "gssize,len"},
	{"func.g_utf8_strchr.arg.2", "gunichar,c"},
	{"func.g_utf8_strchr.args", "3"},
	{"func.g_utf8_strchr.ret", "gchar *"},
	{"func.g_utf8_strdown.arg.0", "const gchar *,str"},
	{"func.g_utf8_strdown.arg.1", "gssize,len"},
	{"func.g_utf8_strdown.args", "2"},
	{"func.g_utf8_strdown.ret", "gchar *"},
	{"func.g_utf8_strlen.arg.0", "const gchar *,p"},
	{"func.g_utf8_strlen.arg.1", "gssize,max"},
	{"func.g_utf8_strlen.args", "2"},
	{"func.g_utf8_strlen.ret", "glong"},
	{"func.g_utf8_strncpy.arg.0", "gchar *,dest"},
	{"func.g_utf8_strncpy.arg.1", "const gchar *,src"},
	{"func.g_utf8_strncpy.arg.2", "gsize,n"},
	{"func.g_utf8_strncpy.args", "3"},
	{"func.g_utf8_strncpy.ret", "gchar *"},
	{"func.g_utf8_strrchr.arg.0", "const gchar *,p"},
	{"func.g_utf8_strrchr.arg.1", "gssize,len"},
	{"func.g_utf8_strrchr.arg.2", "gunichar,c"},
	{"func.g_utf8_strrchr.args", "3"},
	{"func.g_utf8_strrchr.ret", "gchar *"},
	{"func.g_utf8_strreverse.arg.0", "const gchar *,str"},
	{"func.g_utf8_strreverse.arg.1", "gssize,len"},
	{"func.g_utf8_strreverse.args", "2"},
	{"func.g_utf8_strreverse.ret", "gchar *"},
	{"func.g_utf8_strup.arg.0", "const gchar *,str"},
	{"func.g_utf8_strup.arg.1", "gssize,len"},
	{"func.g_utf8_strup.args", "2"},
	{"func.g_utf8_strup.ret", "gchar *"},
	{"func.g_utf8_substring.arg.0", "const gchar *,str"},
	{"func.g_utf8_substring.arg.1", "glong,start_pos"},
	{"func.g_utf8_substring.arg.2", "glong,end_pos"},
	{"func.g_utf8_substring.args", "3"},
	{"func.g_utf8_substring.ret", "gchar *"},
	{"func.g_utf8_to_ucs4.arg.0", "const gchar *,str"},
	{"func.g_utf8_to_ucs4.arg.1", "glong,len"},
	{"func.g_utf8_to_ucs4.arg.2", "glong *,items_read"},
	{"func.g_utf8_to_ucs4.arg.3", "glong *,items_written"},
	{"func.g_utf8_to_ucs4.arg.4", "GError **,error"},
	{"func.g_utf8_to_ucs4.args", "5"},
	{"func.g_utf8_to_ucs4.ret", "gunichar *"},
	{"func.g_utf8_to_ucs4_fast.arg.0", "const gchar *,str"},
	{"func.g_utf8_to_ucs4_fast.arg.1", "glong,len"},
	{"func.g_utf8_to_ucs4_fast.arg.2", "glong *,items_written"},
	{"func.g_utf8_to_ucs4_fast.args", "3"},
	{"func.g_utf8_to_ucs4_fast.ret", "gunichar *"},
	{"func.g_utf8_to_utf16.arg.0", "const gchar *,str"},
	{"func.g_utf8_to_utf16.arg.1", "glong,len"},
	{"func.g_utf8_to_utf16.arg.2", "glong *,items_read"},
	{"func.g_utf8_to_utf16.arg.3", "glong *,items_written"},
	{"func.g_utf8_to_utf16.arg.4", "GError **,error"},
	{"func.g_utf8_to_utf16.args", "5"},
	{"func.g_utf8_to_utf16.ret", "gunichar2 *"},
	{"func.g_utf8_truncate_middle.arg.0", "const gchar *,string"},
	{"func.g_utf8_truncate_middle.arg.1", "gsize,truncate_length"},
	{"func.g_utf8_truncate_middle.args", "2"},
	{"func.g_utf8_truncate_middle.ret", "gchar *"},
	{"func.g_utf8_validate.arg.0", "const gchar *,str"},
	{"func.g_utf8_validate.arg.1", "gssize,max_len"},
	{"func.g_utf8_validate.arg.2", "const gchar **,end"},
	{"func.g_utf8_validate.args", "3"},
	{"func.g_utf8_validate.ret", "gboolean"},
	{"func.g_utf8_validate_len.arg.0", "const gchar *,str"},
	{"func.g_utf8_validate_len.arg.1", "gsize,max_len"},
	{"func.g_utf8_validate_len.arg.2", "const gchar **,end"},
	{"func.g_utf8_validate_len.args", "3"},
	{"func.g_utf8_validate_len.ret", "gboolean"},
	{"func.g_variant_dict_contains.arg.0", "GVariantDict *,dict"},
	{"func.g_variant_dict_contains.arg.1", "const gchar *,key"},
	{"func.g_variant_dict_contains.args", "2"},
	{"func.g_variant_dict_contains.ret", "gboolean"},
	{"func.g_variant_dict_lookup.arg.0", "GVariantDict *,dict"},
	{"func.g_variant_dict_lookup.arg.1", "const gchar *,key"},
	{"func.g_variant_dict_lookup.arg.2", "const gchar *,format_string"},
	{"func.g_variant_dict_lookup.arg.3", ",..."},
	{"func.g_variant_dict_lookup.args", "4"},
	{"func.g_variant_dict_lookup.ret", "gboolean"},
	{"func.g_variant_dict_lookup_value.arg.0", "GVariantDict *,dict"},
	{"func.g_variant_dict_lookup_value.arg.1", "const gchar *,key"},
	{"func.g_variant_dict_lookup_value.arg.2", "const GVariantType *,expected_type"},
	{"func.g_variant_dict_lookup_value.args", "3"},
	{"func.g_variant_dict_lookup_value.ret", "GVariant *"},
	{"func.g_variant_dict_new.arg.0", "GVariant *,from_asv"},
	{"func.g_variant_dict_new.args", "1"},
	{"func.g_variant_dict_new.ret", "GVariantDict *"},
	{"func.g_variant_dict_unref.arg.0", "GVariantDict *,dict"},
	{"func.g_variant_dict_unref.args", "1"},
	{"func.g_variant_dict_unref.ret", "void"},
	{"func.g_variant_get.arg.0", "GVariant *,value"},
	{"func.g_variant_get.arg.1", "const gchar *,format_string"},
	{"func.g_variant_get.arg.2", ",..."},
	{"func.g_variant_get.args", "3"},
	{"func.g_variant_get.ret", "void"},
	{"func.g_variant_get_boolean.arg.0", "GVariant *,value"},
	{"func.g_variant_get_boolean.args", "1"},
	{"func.g_variant_get_boolean.ret", "gboolean"},
	{"func.g_variant_get_child_value.arg.0", "GVariant *,value"},
	{"func.g_variant_get_child_value.arg.1", "gsize,index_"},
	{"func.g_variant_get_child_value.args", "2"},
	{"func.g_variant_get_child_value.ret", "GVariant *"},
	{"func.g_variant_get_double.arg.0", "GVariant *,value"},
	{"func.g_variant_get_double.args", "1"},
	{"func.g_variant_get_double.ret", "gdouble"},
	{"func.g_variant_get_string.arg.0", "GVariant *,value"},
	{"func.g_variant_get_string.arg.1", "gsize *,length"},
	{"func.g_variant_get_string.args", "2"},
	{"func.g_variant_get_string.ret", "const gchar *"},
	{"func.g_variant_iter_init.arg.0", "GVariantIter *,iter"},
	{"func.g_variant_iter_init.arg.1", "GVariant *,value"},
	{"func.g_variant_iter_init.args", "2"},
	{"func.g_variant_iter_init.ret", "gsize"},
	{"func.g_variant_iter_loop.arg.0", "GVariantIter *,iter"},
	{"func.g_variant_iter_loop.arg.1", "const gchar *,format_string"},
	{"func.g_variant_iter_loop.arg.2", ",..."},
	{"func.g_variant_iter_loop.args", "3"},
	{"func.g_variant_iter_loop.ret", "gboolean"},
	{"func.g_variant_new.arg.0", "const gchar *,format_string"},
	{"func.g_variant_new.arg.1", ",..."},
	{"func.g_variant_new.args", "2"},
	{"func.g_variant_new.ret", "GVariant *"},
	{"func.g_variant_unref.arg.0", "GVariant *,value"},
	{"func.g_variant_unref.args", "1"},
	{"func.g_variant_unref.ret", "void"},
	{"g_aligned_alloc", "func"},
	{"g_aligned_alloc0", "func"},
	{"g_aligned_free", "func"},
	{"g_aligned_free_sized", "func"},
	{"g_ascii_digit_value", "func"},
	{"g_ascii_dtostr", "func"},
	{"g_ascii_formatd", "func"},
	{"g_ascii_strcasecmp", "func"},
	{"g_ascii_strdown", "func"},
	{"g_ascii_string_to_signed", "func"},
	{"g_ascii_string_to_unsigned", "func"},
	{"g_ascii_strncasecmp", "func"},
	{"g_ascii_strtod", "func"},
	{"g_ascii_strtoll", "func"},
	{"g_ascii_strtoull", "func"},
	{"g_ascii_strup", "func"},
	{"g_ascii_tolower", "func"},
	{"g_ascii_toupper", "func"},
	{"g_ascii_xdigit_value", "func"},
	{"g_base64_decode", "func"},
	{"g_base64_decode_inplace", "func"},
	{"g_base64_decode_step", "func"},
	{"g_base64_encode", "func"},
	{"g_base64_encode_close", "func"},
	{"g_base64_encode_step", "func"},
	{"g_build_filename", "func"},
	{"g_build_filenamev", "func"},
	{"g_build_path", "func"},
	{"g_build_pathv", "func"},
	{"g_canonicalize_filename", "func"},
	{"g_clear_error", "func"},
	{"g_dir_make_tmp", "func"},
	{"g_environ_getenv", "func"},
	{"g_environ_setenv", "func"},
	{"g_environ_unsetenv", "func"},
	{"g_error_copy", "func"},
	{"g_error_free", "func"},
	{"g_error_matches", "func"},
	{"g_error_new", "func"},
	{"g_error_new_literal", "func"},
	{"g_error_new_valist", "func"},
	{"g_file_get_contents", "func"},
	{"g_file_read_link", "func"},
	{"g_file_set_contents", "func"},
	{"g_file_test", "func"},
	{"g_free", "func"},
	{"g_free_sized", "func"},
	{"g_get_current_dir", "func"},
	{"g_get_environ", "func"},
	{"g_get_home_dir", "func"},
	{"g_get_prgname", "func"},
	{"g_get_tmp_dir", "func"},
	{"g_get_user_cache_dir", "func"},
	{"g_get_user_data_dir", "func"},
	{"g_get_user_name", "func"},
	{"g_getenv", "func"},
	{"g_hash_table_contains", "func"},
	{"g_hash_table_destroy", "func"},
	{"g_hash_table_get_values", "func"},
	{"g_hash_table_insert", "func"},
	{"g_hash_table_lookup", "func"},
	{"g_hash_table_new_full", "func"},
	{"g_intern_static_string", "func"},
	{"g_intern_string", "func"},
	{"g_key_file_load_from_data", "func"},
	{"g_key_file_new", "func"},
	{"g_key_file_unref", "func"},
	{"g_malloc", "func"},
	{"g_malloc0", "func"},
	{"g_malloc0_n", "func"},
	{"g_malloc_n", "func"},
	{"g_memdup", "func"},
	{"g_memdup2", "func"},
	{"g_mkdir_with_parents", "func"},
	{"g_option_context_add_group", "func"},
	{"g_option_context_add_main_entries", "func"},
	{"g_option_context_free", "func"},
	{"g_option_context_get_help", "func"},
	{"g_option_context_new", "func"},
	{"g_option_context_parse", "func"},
	{"g_option_context_set_help_enabled", "func"},
	{"g_option_context_set_summary", "func"},
	{"g_option_group_add_entries", "func"},
	{"g_option_group_new", "func"},
	{"g_path_get_basename", "func"},
	{"g_path_get_dirname", "func"},
	{"g_path_is_absolute", "func"},
	{"g_path_skip_root", "func"},
	{"g_prefix_error", "func"},
	{"g_prefix_error_literal", "func"},
	{"g_print", "func"},
	{"g_printerr", "func"},
	{"g_propagate_error", "func"},
	{"g_propagate_prefixed_error", "func"},
	{"g_ptr_array_add", "func"},
	{"g_ptr_array_free", "func"},
	{"g_ptr_array_new_with_free_func", "func"},
	{"g_ptr_array_ref", "func"},
	{"g_ptr_array_sort", "func"},
	{"g_ptr_array_unref", "func"},
	{"g_quark_from_static_string", "func"},
	{"g_quark_from_string", "func"},
	{"g_quark_to_string", "func"},
	{"g_quark_try_string", "func"},
	{"g_realloc", "func"},
	{"g_realloc_n", "func"},
	{"g_set_error", "func"},
	{"g_set_error_literal", "func"},
	{"g_set_prgname", "func"},
	{"g_set_printerr_handler", "func"},
	{"g_setenv", "func"},
	{"g_shell_error_quark", "func"},
	{"g_shell_parse_argv", "func"},
	{"g_shell_quote", "func"},
	{"g_shell_unquote", "func"},
	{"g_stpcpy", "func"},
	{"g_str_equal", "func"},
	{"g_str_has_prefix", "func"},
	{"g_str_has_suffix", "func"},
	{"g_str_hash", "func"},
	{"g_str_is_ascii", "func"},
	{"g_str_match_string", "func"},
	{"g_str_to_ascii", "func"},
	{"g_str_tokenize_and_fold", "func"},
	{"g_strcanon", "func"},
	{"g_strcasecmp", "func"},
	{"g_strchomp", "func"},
	{"g_strchug", "func"},
	{"g_strcmp0", "func"},
	{"g_strcompress", "func"},
	{"g_strconcat", "func"},
	{"g_strdelimit", "func"},
	{"g_strdown", "func"},
	{"g_strdup", "func"},
	{"g_strdup_printf", "func"},
	{"g_strdup_vprintf", "func"},
	{"g_strdupv", "func"},
	{"g_strerror", "func"},
	{"g_strescape", "func"},
	{"g_strfreev", "func"},
	{"g_string_append", "func"},
	{"g_string_append_c", "func"},
	{"g_string_append_len", "func"},
	{"g_string_append_printf", "func"},
	{"g_string_append_unichar", "func"},
	{"g_string_append_uri_escaped", "func"},
	{"g_string_append_vprintf", "func"},
	{"g_string_ascii_down", "func"},
	{"g_string_ascii_up", "func"},
	{"g_string_assign", "func"},
	{"g_string_chunk_clear", "func"},
	{"g_string_chunk_free", "func"},
	{"g_string_chunk_insert", "func"},
	{"g_string_chunk_insert_const", "func"},
	{"g_string_chunk_insert_len", "func"},
	{"g_string_chunk_new", "func"},
	{"g_string_copy", "func"},
	{"g_string_down", "func"},
	{"g_string_equal", "func"},
	{"g_string_erase", "func"},
	{"g_string_free", "func"},
	{"g_string_free_and_steal", "func"},
	{"g_string_free_deep", "func"},
	{"g_string_free_to_bytes", "func"},
	{"g_string_hash", "func"},
	{"g_string_insert", "func"},
	{"g_string_insert_c", "func"},
	{"g_string_insert_len", "func"},
	{"g_string_insert_unichar", "func"},
	{"g_string_new", "func"},
	{"g_string_new_len", "func"},
	{"g_string_new_take", "func"},
	{"g_string_overwrite", "func"},
	{"g_string_overwrite_len", "func"},
	{"g_string_prepend", "func"},
	{"g_string_prepend_c", "func"},
	{"g_string_prepend_len", "func"},
	{"g_string_prepend_unichar", "func"},
	{"g_string_printf", "func"},
	{"g_string_replace", "func"},
	{"g_string_set_size", "func"},
	{"g_string_sized_new", "func"},
	{"g_string_truncate", "func"},
	{"g_string_up", "func"},
	{"g_string_vprintf", "func"},
	{"g_strip_context", "func"},
	{"g_strjoin", "func"},
	{"g_strjoinv", "func"},
	{"g_strlcat", "func"},
	{"g_strlcpy", "func"},
	{"g_strncasecmp", "func"},
	{"g_strndup", "func"},
	{"g_strnfill", "func"},
	{"g_strreverse", "func"},
	{"g_strrstr", "func"},
	{"g_strrstr_len", "func"},
	{"g_strsignal", "func"},
	{"g_strsplit", "func"},
	{"g_strsplit_set", "func"},
	{"g_strstr_len", "func"},
	{"g_strtod", "func"},
	{"g_strup", "func"},
	{"g_strv_contains", "func"},
	{"g_strv_equal", "func"},
	{"g_strv_length", "func"},
	{"g_try_malloc", "func"},
	{"g_try_malloc0", "func"},
	{"g_try_malloc0_n", "func"},
	{"g_try_malloc_n", "func"},
	{"g_try_realloc", "func"},
	{"g_try_realloc_n", "func"},
	{"g_ucs4_to_utf16", "func"},
	{"g_ucs4_to_utf8", "func"},
	{"g_unichar_to_utf8", "func"},
	{"g_unsetenv", "func"},
	{"g_utf16_to_ucs4", "func"},
	{"g_utf16_to_utf8", "func"},
	{"g_utf8_casefold", "func"},
	{"g_utf8_collate", "func"},
	{"g_utf8_collate_key", "func"},
	{"g_utf8_collate_key_for_filename", "func"},
	{"g_utf8_find_next_char", "func"},
	{"g_utf8_find_prev_char", "func"},
	{"g_utf8_get_char", "func"},
	{"g_utf8_get_char_validated", "func"},
	{"g_utf8_make_valid", "func"},
	{"g_utf8_normalize", "func"},
	{"g_utf8_offset_to_pointer", "func"},
	{"g_utf8_pointer_to_offset", "func"},
	{"g_utf8_prev_char", "func"},
	{"g_utf8_strchr", "func"},
	{"g_utf8_strdown", "func"},
	{"g_utf8_strlen", "func"},
	{"g_utf8_strncpy", "func"},
	{"g_utf8_strrchr", "func"},
	{"g_utf8_strreverse", "func"},
	{"g_utf8_strup", "func"},
	{"g_utf8_substring", "func"},
	{"g_utf8_to_ucs4", "func"},
	{"g_utf8_to_ucs4_fast", "func"},
	{"g_utf8_to_utf16", "func"},
	{"g_utf8_truncate_middle", "func"},
	{"g_utf8_validate", "func"},
	{"g_utf8_validate_len", "func"},
	{"g_variant_dict_contains", "func"},
	{"g_variant_dict_lookup", "func"},
	{"g_variant_dict_lookup_value", "func"},
	{"g_variant_dict_new", "func"},
	{"g_variant_dict_unref", "func"},
	{"g_variant_get", "func"},
	{"g_variant_get_boolean", "func"},
	{"g_variant_get_child_value", "func"},
	{"g_variant_get_double", "func"},
	{"g_variant_get_string", "func"},
	{"g_variant_iter_init", "func"},
	{"g_variant_iter_loop", "func"},
	{"g_variant_new", "func"},
	{"g_variant_unref", "func"},
	{"gboolean", "typedef"},
	{"gchar", "typedef"},
	{"gconstpointer", "typedef"},
	{"gdouble", "typedef"},
	{"gfloat", "typedef"},
	{"gint", "typedef"},
	{"gint16", "typedef"},
	{"gint32", "typedef"},
	{"gint64", "typedef"},
	{"gint8", "typedef"},
	{"gintptr", "typedef"},
	{"glong", "typedef"},
	{"goffset", "typedef"},
	{"gpointer", "typedef"},
	{"gshort", "typedef"},
	{"gsize", "typedef"},
	{"gssize", "typedef"},
	{"guchar", "typedef"},
	{"guint", "typedef"},
	{"guint16", "typedef"},
	{"guint32", "typedef"},
	{"guint64", "typedef"},
	{"guint8", "typedef"},
	{"guintptr", "typedef"},
	{"gulong", "typedef"},
	{"gunichar", "typedef"},
	{"gunichar2", "typedef"},
	{"gushort", "typedef"},
	{"typedef.GBytes", "struct _GBytes"},
	{"typedef.GCompareFunc", "gint (*)(gconstpointer, gconstpointer)"},
	{"typedef.GDestroyNotify", "void (*)(gpointer)"},
	{"typedef.GDuplicateFunc", "gpointer (*)(gpointer, gpointer)"},
	{"typedef.GEqualFunc", "gboolean (*)(gconstpointer, gconstpointer)"},
	{"typedef.GError", "struct _GError"},
	{"typedef.GHashFunc", "guint (*)(gconstpointer)"},
	{"typedef.GHashTable", "struct _GHashTable"},
	{"typedef.GKeyFile", "struct _GKeyFile"},
	{"typedef.GList", "struct _GList"},
	{"typedef.GOptionContext", "struct _GOptionContext"},
	{"typedef.GOptionEntry", "struct _GOptionEntry"},
	{"typedef.GOptionGroup", "struct _GOptionGroup"},
	{"typedef.GPrintFunc", "void (*)(const gchar *)"},
	{"typedef.GPtrArray", "struct _GPtrArray"},
	{"typedef.GQuark", "guint32"},
	{"typedef.GString", "struct _GString"},
	{"typedef.GStringChunk", "struct _GStringChunk"},
	{"typedef.GStrv", "gchar **"},
	{"typedef.GVariant", "struct _GVariant"},
	{"typedef.GVariantDict", "struct _GVariantDict"},
	{"typedef.GVariantIter", "struct _GVariantIter"},
	{"typedef.GVariantType", "struct _GVariantType"},
	{"typedef.gboolean", "gint"},
	{"typedef.gchar", "char"},
	{"typedef.gconstpointer", "const void *"},
	{"typedef.gdouble", "double"},
	{"typedef.gfloat", "float"},
	{"typedef.gint", "int"},
	{"typedef.gint16", "int16_t"},
	{"typedef.gint32", "int32_t"},
	{"typedef.gint64", "int64_t"},
	{"typedef.gint8", "int8_t"},
	{"typedef.gintptr", "ssize_t"},
	{"typedef.glong", "long"},
	{"typedef.goffset", "gint64"},
	{"typedef.gpointer", "void *"},
	{"typedef.gshort", "short"},
	{"typedef.gsize", "size_t"},
	{"typedef.gssize", "ssize_t"},
	{"typedef.guchar", "unsigned char"},
	{"typedef.guint", "unsigned int"},
	{"typedef.guint16", "uint16_t"},
	{"typedef.guint32", "uint32_t"},
	{"typedef.guint64", "uint64_t"},
	{"typedef.guint8", "uint8_t"},
	{"typedef.guintptr", "size_t"},
	{"typedef.gulong", "unsigned long"},
	{"typedef.gunichar", "guint32"},
	{"typedef.gunichar2", "guint16"},
	{"typedef.gushort", "unsigned short"},
  {NULL, NULL}
};
typedef int (*GperfForeachCallback)(void *user, const char *k, const char *v);
int gperf_types_glib_foreach(GperfForeachCallback cb, void *user) {
  int i = 0; while (kvs[i].name) {
  cb (user, kvs[i].name, kvs[i].value);
  i++;}
  return 0;
}
const char *gperf_types_glib_get(const char *s) {
  int i = 0; while (kvs[i].name) {
  if (!strcmp (s, kvs[i].name)) return kvs[i].value;
  i++;}
  return NULL;
}
#define sdb_hash_c_types_glib(x,y) gperf_types_glib_hash(x)
const unsigned int gperf_types_glib_hash(const char *s) {
  int sum = strlen (s);
  while (*s) { sum += *s; s++; }
  return sum;
}
struct {const char *name;void *get;void *hash;void *foreach;} gperf_types_glib = {
  .name = "types-glib",
  .get = &gperf_types_glib_get,
  .hash = &gperf_types_glib_hash,
  .foreach = &gperf_types_glib_foreach
};

#if MAIN
int main () {
	const char *s = ((char*(*)(char*))gperf_types_glib.get)("foo");
	printf ("%s\n", s);
}
#endif