Attachment 308912 Details for Bug 450790 – gobect.i

gobect.i

gsignal.i (text/plain), 451.19 KB, created by David Woodhouse on 2008-06-11 09:12:09 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: David Woodhouse

Created: 2008-06-11 09:12:09 UTC

Size: 451.19 KB

patch

obsolete

># 1 "gsignal.c"
># 1 "/home/dwmw2/working/extras/glib2/F-9/glib-2.16.3/gobject//"
># 1 "<built-in>"
># 1 "<command-line>"
># 1 "gsignal.c"
># 27 "gsignal.c"
># 1 "../config.h" 1
># 28 "gsignal.c" 2
>
># 1 "gsignal.h" 1
># 26 "gsignal.h"
># 1 "../gobject/gclosure.h" 1
># 27 "../gobject/gclosure.h"
># 1 "../gobject/gtype.h" 1
># 26 "../gobject/gtype.h"
># 1 "../glib/glib.h" 1
># 30 "../glib/glib.h"
># 1 "../glib/galloca.h" 1
># 30 "../glib/galloca.h"
># 1 "../glib/gtypes.h" 1
># 30 "../glib/gtypes.h"
># 1 "../glibconfig.h" 1
># 9 "../glibconfig.h"
># 1 "../glib/gmacros.h" 1
># 36 "../glib/gmacros.h"
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 152 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 3 4
>typedef int ptrdiff_t;
># 214 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 3 4
>typedef unsigned int size_t;
># 326 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 3 4
>typedef long int wchar_t;
># 37 "../glib/gmacros.h" 2
># 10 "../glibconfig.h" 2
>
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/limits.h" 1 3 4
># 11 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/limits.h" 3 4
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/syslimits.h" 1 3 4
>
>
>
>
>
>
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/limits.h" 1 3 4
># 122 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/limits.h" 3 4
># 1 "/usr/include/limits.h" 1 3 4
># 27 "/usr/include/limits.h" 3 4
># 1 "/usr/include/features.h" 1 3 4
># 335 "/usr/include/features.h" 3 4
># 1 "/usr/include/sys/cdefs.h" 1 3 4
># 360 "/usr/include/sys/cdefs.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 361 "/usr/include/sys/cdefs.h" 2 3 4
># 336 "/usr/include/features.h" 2 3 4
># 359 "/usr/include/features.h" 3 4
># 1 "/usr/include/gnu/stubs.h" 1 3 4
>
>
>
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 5 "/usr/include/gnu/stubs.h" 2 3 4
>
>
># 1 "/usr/include/gnu/stubs-32.h" 1 3 4
># 8 "/usr/include/gnu/stubs.h" 2 3 4
># 360 "/usr/include/features.h" 2 3 4
># 28 "/usr/include/limits.h" 2 3 4
># 145 "/usr/include/limits.h" 3 4
># 1 "/usr/include/bits/posix1_lim.h" 1 3 4
># 153 "/usr/include/bits/posix1_lim.h" 3 4
># 1 "/usr/include/bits/local_lim.h" 1 3 4
># 40 "/usr/include/bits/local_lim.h" 3 4
># 1 "/usr/include/linux/limits.h" 1 3 4
># 41 "/usr/include/bits/local_lim.h" 2 3 4
># 154 "/usr/include/bits/posix1_lim.h" 2 3 4
># 146 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/posix2_lim.h" 1 3 4
># 150 "/usr/include/limits.h" 2 3 4
># 123 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/limits.h" 2 3 4
># 8 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/syslimits.h" 2 3 4
># 12 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/limits.h" 2 3 4
># 12 "../glibconfig.h" 2
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/float.h" 1 3 4
># 13 "../glibconfig.h" 2
>
>
>
>
># 32 "../glibconfig.h"
>typedef signed char gint8;
>typedef unsigned char guint8;
>typedef signed short gint16;
>typedef unsigned short guint16;
>
>
>
>typedef signed int gint32;
>typedef unsigned int guint32;
>
>
>
>
>
>__extension__ typedef signed long long gint64;
>__extension__ typedef unsigned long long guint64;
># 59 "../glibconfig.h"
>typedef signed int gssize;
>typedef unsigned int gsize;
># 69 "../glibconfig.h"
>typedef gint64 goffset;
># 141 "../glibconfig.h"
>typedef struct _GStaticMutex GStaticMutex;
>struct _GStaticMutex
>{
>  struct _GMutex *runtime_mutex;
>  union {
>    char pad[24];
>    double dummy_double;
>    void *dummy_pointer;
>    long dummy_long;
>  } static_mutex;
>};
># 166 "../glibconfig.h"
>typedef union _GSystemThread GSystemThread;
>union _GSystemThread
>{
>  char data[4];
>  double dummy_double;
>  void *dummy_pointer;
>  long dummy_long;
>};
># 208 "../glibconfig.h"
>typedef int GPid;
>
>
># 31 "../glib/gtypes.h" 2
>
>
># 41 "../glib/gtypes.h"
>typedef char gchar;
>typedef short gshort;
>typedef long glong;
>typedef int gint;
>typedef gint gboolean;
>
>typedef unsigned char guchar;
>typedef unsigned short gushort;
>typedef unsigned long gulong;
>typedef unsigned int guint;
>
>typedef float gfloat;
>typedef double gdouble;
># 72 "../glib/gtypes.h"
>typedef void* gpointer;
>typedef const void *gconstpointer;
>
>typedef gint (*GCompareFunc) (gconstpointer a,
>                                                 gconstpointer b);
>typedef gint (*GCompareDataFunc) (gconstpointer a,
>                                                 gconstpointer b,
>       gpointer user_data);
>typedef gboolean (*GEqualFunc) (gconstpointer a,
>                                                 gconstpointer b);
>typedef void (*GDestroyNotify) (gpointer data);
>typedef void (*GFunc) (gpointer data,
>                                                 gpointer user_data);
>typedef guint (*GHashFunc) (gconstpointer key);
>typedef void (*GHFunc) (gpointer key,
>                                                 gpointer value,
>                                                 gpointer user_data);
>typedef void (*GFreeFunc) (gpointer data);
>typedef const gchar * (*GTranslateFunc) (const gchar *str,
>       gpointer data);
># 345 "../glib/gtypes.h"
>typedef union _GDoubleIEEE754 GDoubleIEEE754;
>typedef union _GFloatIEEE754 GFloatIEEE754;
># 372 "../glib/gtypes.h"
>union _GFloatIEEE754
>{
>  gfloat v_float;
>  struct {
>    guint sign : 1;
>    guint biased_exponent : 8;
>    guint mantissa : 23;
>  } mpn;
>};
>union _GDoubleIEEE754
>{
>  gdouble v_double;
>  struct {
>    guint sign : 1;
>    guint biased_exponent : 11;
>    guint mantissa_high : 20;
>    guint mantissa_low : 32;
>  } mpn;
>};
>
>
>
>
>typedef struct _GTimeVal GTimeVal;
>
>struct _GTimeVal
>{
>  glong tv_sec;
>  glong tv_usec;
>};
>
>
># 31 "../glib/galloca.h" 2
># 31 "../glib/glib.h" 2
># 1 "../glib/garray.h" 1
># 32 "../glib/garray.h"
>
>
>typedef struct _GArray GArray;
>typedef struct _GByteArray GByteArray;
>typedef struct _GPtrArray GPtrArray;
>
>struct _GArray
>{
>  gchar *data;
>  guint len;
>};
>
>struct _GByteArray
>{
>  guint8 *data;
>  guint len;
>};
>
>struct _GPtrArray
>{
>  gpointer *pdata;
>  guint len;
>};
># 66 "../glib/garray.h"
>GArray* g_array_new (gboolean zero_terminated,
>       gboolean clear_,
>       guint element_size);
>GArray* g_array_sized_new (gboolean zero_terminated,
>       gboolean clear_,
>       guint element_size,
>       guint reserved_size);
>gchar* g_array_free (GArray *array,
>       gboolean free_segment);
>GArray* g_array_append_vals (GArray *array,
>       gconstpointer data,
>       guint len);
>GArray* g_array_prepend_vals (GArray *array,
>       gconstpointer data,
>       guint len);
>GArray* g_array_insert_vals (GArray *array,
>       guint index_,
>       gconstpointer data,
>       guint len);
>GArray* g_array_set_size (GArray *array,
>       guint length);
>GArray* g_array_remove_index (GArray *array,
>       guint index_);
>GArray* g_array_remove_index_fast (GArray *array,
>       guint index_);
>GArray* g_array_remove_range (GArray *array,
>       guint index_,
>       guint length);
>void g_array_sort (GArray *array,
>       GCompareFunc compare_func);
>void g_array_sort_with_data (GArray *array,
>       GCompareDataFunc compare_func,
>       gpointer user_data);
>
>
>
>
>
>
>GPtrArray* g_ptr_array_new (void);
>GPtrArray* g_ptr_array_sized_new (guint reserved_size);
>gpointer* g_ptr_array_free (GPtrArray *array,
>        gboolean free_seg);
>void g_ptr_array_set_size (GPtrArray *array,
>        gint length);
>gpointer g_ptr_array_remove_index (GPtrArray *array,
>        guint index_);
>gpointer g_ptr_array_remove_index_fast (GPtrArray *array,
>        guint index_);
>gboolean g_ptr_array_remove (GPtrArray *array,
>        gpointer data);
>gboolean g_ptr_array_remove_fast (GPtrArray *array,
>        gpointer data);
>void g_ptr_array_remove_range (GPtrArray *array,
>        guint index_,
>        guint length);
>void g_ptr_array_add (GPtrArray *array,
>        gpointer data);
>void g_ptr_array_sort (GPtrArray *array,
>        GCompareFunc compare_func);
>void g_ptr_array_sort_with_data (GPtrArray *array,
>        GCompareDataFunc compare_func,
>        gpointer user_data);
>void g_ptr_array_foreach (GPtrArray *array,
>        GFunc func,
>        gpointer user_data);
>
>
>
>
>
>
>GByteArray* g_byte_array_new (void);
>GByteArray* g_byte_array_sized_new (guint reserved_size);
>guint8* g_byte_array_free (GByteArray *array,
>         gboolean free_segment);
>GByteArray* g_byte_array_append (GByteArray *array,
>         const guint8 *data,
>         guint len);
>GByteArray* g_byte_array_prepend (GByteArray *array,
>         const guint8 *data,
>         guint len);
>GByteArray* g_byte_array_set_size (GByteArray *array,
>         guint length);
>GByteArray* g_byte_array_remove_index (GByteArray *array,
>         guint index_);
>GByteArray* g_byte_array_remove_index_fast (GByteArray *array,
>         guint index_);
>GByteArray* g_byte_array_remove_range (GByteArray *array,
>         guint index_,
>         guint length);
>void g_byte_array_sort (GByteArray *array,
>         GCompareFunc compare_func);
>void g_byte_array_sort_with_data (GByteArray *array,
>         GCompareDataFunc compare_func,
>         gpointer user_data);
>
>
>
># 32 "../glib/glib.h" 2
># 1 "../glib/gasyncqueue.h" 1
># 30 "../glib/gasyncqueue.h"
># 1 "../glib/gthread.h" 1
># 30 "../glib/gthread.h"
># 1 "../glib/gerror.h" 1
># 24 "../glib/gerror.h"
># 1 "../glib/gquark.h" 1
># 32 "../glib/gquark.h"
>
>
>typedef guint32 GQuark;
>
>
>
>GQuark g_quark_try_string (const gchar *string);
>GQuark g_quark_from_static_string (const gchar *string);
>GQuark g_quark_from_string (const gchar *string);
> gchar* g_quark_to_string (GQuark quark) __attribute__((__const__));
>
> gchar* g_intern_string (const gchar *string);
> gchar* g_intern_static_string (const gchar *string);
>
>
>
># 25 "../glib/gerror.h" 2
>
>
>
>typedef struct _GError GError;
>
>struct _GError
>{
>  GQuark domain;
>  gint code;
>  gchar *message;
>};
>
>GError* g_error_new (GQuark domain,
>                                gint code,
>                                const gchar *format,
>                                ...) __attribute__((__format__ (__printf__, 3, 4)));
>
>GError* g_error_new_literal (GQuark domain,
>                                gint code,
>                                const gchar *message);
>
>void g_error_free (GError *error);
>GError* g_error_copy (const GError *error);
>
>gboolean g_error_matches (const GError *error,
>                                GQuark domain,
>                                gint code);
>
>
>
>
>void g_set_error (GError **err,
>                                GQuark domain,
>                                gint code,
>                                const gchar *format,
>                                ...) __attribute__((__format__ (__printf__, 4, 5)));
>
>
>
>void g_propagate_error (GError **dest,
>    GError *src);
>
>
>void g_clear_error (GError **err);
>
>
>void g_prefix_error (GError **err,
>                                       const gchar *format,
>                                       ...) __attribute__((__format__ (__printf__, 2, 3)));
>
>
>void g_propagate_prefixed_error (GError **dest,
>                                       GError *src,
>                                       const gchar *format,
>                                       ...) __attribute__((__format__ (__printf__, 3, 4)));
>
>
># 31 "../glib/gthread.h" 2
>
># 1 "../glib/gutils.h" 1
># 31 "../glib/gutils.h"
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stdarg.h" 1 3 4
># 43 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stdarg.h" 3 4
>typedef __builtin_va_list __gnuc_va_list;
># 105 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stdarg.h" 3 4
>typedef __gnuc_va_list va_list;
># 32 "../glib/gutils.h" 2
>
>
># 120 "../glib/gutils.h"
> gchar* g_get_user_name (void);
> gchar* g_get_real_name (void);
> gchar* g_get_home_dir (void);
> gchar* g_get_tmp_dir (void);
> gchar* g_get_host_name (void);
>gchar* g_get_prgname (void);
>void g_set_prgname (const gchar *prgname);
> gchar* g_get_application_name (void);
>void g_set_application_name (const gchar *application_name);
>
> gchar* g_get_user_data_dir (void);
> gchar* g_get_user_config_dir (void);
> gchar* g_get_user_cache_dir (void);
> gchar* * g_get_system_data_dirs (void);
># 148 "../glib/gutils.h"
> gchar* * g_get_system_config_dirs (void);
>
> gchar* * g_get_language_names (void);
># 174 "../glib/gutils.h"
>typedef enum {
>  G_USER_DIRECTORY_DESKTOP,
>  G_USER_DIRECTORY_DOCUMENTS,
>  G_USER_DIRECTORY_DOWNLOAD,
>  G_USER_DIRECTORY_MUSIC,
>  G_USER_DIRECTORY_PICTURES,
>  G_USER_DIRECTORY_PUBLIC_SHARE,
>  G_USER_DIRECTORY_TEMPLATES,
>  G_USER_DIRECTORY_VIDEOS,
>
>  G_USER_N_DIRECTORIES
>} GUserDirectory;
>
> gchar* g_get_user_special_dir (GUserDirectory directory);
>
>typedef struct _GDebugKey GDebugKey;
>struct _GDebugKey
>{
>  gchar *key;
>  guint value;
>};
>
>
>
>guint g_parse_debug_string (const gchar *string,
>         const GDebugKey *keys,
>         guint nkeys);
>
>gint g_snprintf (gchar *string,
>         gulong n,
>         gchar const *format,
>         ...) __attribute__((__format__ (__printf__, 3, 4)));
>gint g_vsnprintf (gchar *string,
>         gulong n,
>         gchar const *format,
>         va_list args);
>
>
>gboolean g_path_is_absolute (const gchar *file_name);
>
>
> gchar* g_path_skip_root (const gchar *file_name);
># 233 "../glib/gutils.h"
>gchar* g_get_current_dir (void);
>gchar* g_path_get_basename (const gchar *file_name) __attribute__((__malloc__));
>gchar* g_path_get_dirname (const gchar *file_name) __attribute__((__malloc__));
>
>
>void g_nullify_pointer (gpointer *nullify_location);
># 249 "../glib/gutils.h"
> gchar* g_getenv (const gchar *variable);
>gboolean g_setenv (const gchar *variable,
>         const gchar *value,
>         gboolean overwrite);
>void g_unsetenv (const gchar *variable);
>gchar** g_listenv (void);
>
>
>const gchar* _g_getenv_nomalloc (const gchar *variable,
>         gchar buffer[1024]);
>
>
>
>
>
>typedef void (*GVoidFunc) (void);
># 275 "../glib/gutils.h"
>void g_atexit (GVoidFunc func);
># 289 "../glib/gutils.h"
>gchar* g_find_program_in_path (const gchar *program);
>
>
>
>extern inline __attribute__ ((__gnu_inline__)) gint g_bit_nth_lsf (gulong mask,
>           gint nth_bit) __attribute__((__const__));
>extern inline __attribute__ ((__gnu_inline__)) gint g_bit_nth_msf (gulong mask,
>           gint nth_bit) __attribute__((__const__));
>extern inline __attribute__ ((__gnu_inline__)) guint g_bit_storage (gulong number) __attribute__((__const__));
>
>
>
>
>typedef struct _GTrashStack GTrashStack;
>struct _GTrashStack
>{
>  GTrashStack *next;
>};
>
>extern inline __attribute__ ((__gnu_inline__)) void g_trash_stack_push (GTrashStack **stack_p,
>       gpointer data_p);
>extern inline __attribute__ ((__gnu_inline__)) gpointer g_trash_stack_pop (GTrashStack **stack_p);
>extern inline __attribute__ ((__gnu_inline__)) gpointer g_trash_stack_peek (GTrashStack **stack_p);
>extern inline __attribute__ ((__gnu_inline__)) guint g_trash_stack_height (GTrashStack **stack_p);
>
>
>
>
>extern inline __attribute__ ((__gnu_inline__)) gint
>g_bit_nth_lsf (gulong mask,
>        gint nth_bit)
>{
>  if ((__builtin_expect (__extension__ ({ int _g_boolean_var_; if (nth_bit < -1) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 0)))
>    nth_bit = -1;
>  while (nth_bit < ((4 * 8) - 1))
>    {
>      nth_bit++;
>      if (mask & (1UL << nth_bit))
> return nth_bit;
>    }
>  return -1;
>}
>extern inline __attribute__ ((__gnu_inline__)) gint
>g_bit_nth_msf (gulong mask,
>        gint nth_bit)
>{
>  if (nth_bit < 0 || (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (nth_bit > 4 * 8) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 0)))
>    nth_bit = 4 * 8;
>  while (nth_bit > 0)
>    {
>      nth_bit--;
>      if (mask & (1UL << nth_bit))
> return nth_bit;
>    }
>  return -1;
>}
>extern inline __attribute__ ((__gnu_inline__)) guint
>g_bit_storage (gulong number)
>{
>
>  return (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (number) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) ?
>    ((4 * 8 - 1) ^ __builtin_clzl(number)) + 1 : 1;
># 362 "../glib/gutils.h"
>}
>extern inline __attribute__ ((__gnu_inline__)) void
>g_trash_stack_push (GTrashStack **stack_p,
>      gpointer data_p)
>{
>  GTrashStack *data = (GTrashStack *) data_p;
>
>  data->next = *stack_p;
>  *stack_p = data;
>}
>extern inline __attribute__ ((__gnu_inline__)) gpointer
>g_trash_stack_pop (GTrashStack **stack_p)
>{
>  GTrashStack *data;
>
>  data = *stack_p;
>  if (data)
>    {
>      *stack_p = data->next;
>
>
>
>      data->next = ((void *)0);
>    }
>
>  return data;
>}
>extern inline __attribute__ ((__gnu_inline__)) gpointer
>g_trash_stack_peek (GTrashStack **stack_p)
>{
>  GTrashStack *data;
>
>  data = *stack_p;
>
>  return data;
>}
>extern inline __attribute__ ((__gnu_inline__)) guint
>g_trash_stack_height (GTrashStack **stack_p)
>{
>  GTrashStack *data;
>  guint i = 0;
>
>  for (data = *stack_p; data; data = data->next)
>    i++;
>
>  return i;
>}
>
>
>
>
>
>
>extern const guint glib_major_version;
>extern const guint glib_minor_version;
>extern const guint glib_micro_version;
>extern const guint glib_interface_age;
>extern const guint glib_binary_age;
>
>const gchar * glib_check_version (guint required_major,
>                                  guint required_minor,
>                                  guint required_micro);
>
>
>
>
>
>
>
>
># 33 "../glib/gthread.h" 2
># 1 "../glib/gatomic.h" 1
># 35 "../glib/gatomic.h"
>
>
>gint g_atomic_int_exchange_and_add (volatile gint *atomic,
>      gint val);
>void g_atomic_int_add (volatile gint *atomic,
>      gint val);
>gboolean g_atomic_int_compare_and_exchange (volatile gint *atomic,
>      gint oldval,
>      gint newval);
>gboolean g_atomic_pointer_compare_and_exchange (volatile gpointer *atomic,
>      gpointer oldval,
>      gpointer newval);
>
>gint g_atomic_int_get (volatile gint *atomic);
>void g_atomic_int_set (volatile gint *atomic,
>      gint newval);
>gpointer g_atomic_pointer_get (volatile gpointer *atomic);
>void g_atomic_pointer_set (volatile gpointer *atomic,
>      gpointer newval);
># 66 "../glib/gatomic.h"
>
># 34 "../glib/gthread.h" 2
>
>
>
>
>
>
>extern GQuark g_thread_error_quark (void);
>
>
>typedef enum
>{
>  G_THREAD_ERROR_AGAIN
>} GThreadError;
>
>typedef gpointer (*GThreadFunc) (gpointer data);
>
>typedef enum
>{
>  G_THREAD_PRIORITY_LOW,
>  G_THREAD_PRIORITY_NORMAL,
>  G_THREAD_PRIORITY_HIGH,
>  G_THREAD_PRIORITY_URGENT
>} GThreadPriority;
>
>typedef struct _GThread GThread;
>struct _GThread
>{
>
>  GThreadFunc func;
>  gpointer data;
>  gboolean joinable;
>  GThreadPriority priority;
>};
>
>typedef struct _GMutex GMutex;
>typedef struct _GCond GCond;
>typedef struct _GPrivate GPrivate;
>typedef struct _GStaticPrivate GStaticPrivate;
>
>typedef struct _GThreadFunctions GThreadFunctions;
>struct _GThreadFunctions
>{
>  GMutex* (*mutex_new) (void);
>  void (*mutex_lock) (GMutex *mutex);
>  gboolean (*mutex_trylock) (GMutex *mutex);
>  void (*mutex_unlock) (GMutex *mutex);
>  void (*mutex_free) (GMutex *mutex);
>  GCond* (*cond_new) (void);
>  void (*cond_signal) (GCond *cond);
>  void (*cond_broadcast) (GCond *cond);
>  void (*cond_wait) (GCond *cond,
>                                   GMutex *mutex);
>  gboolean (*cond_timed_wait) (GCond *cond,
>                                   GMutex *mutex,
>                                   GTimeVal *end_time);
>  void (*cond_free) (GCond *cond);
>  GPrivate* (*private_new) (GDestroyNotify destructor);
>  gpointer (*private_get) (GPrivate *private_key);
>  void (*private_set) (GPrivate *private_key,
>                                   gpointer data);
>  void (*thread_create) (GThreadFunc func,
>                                   gpointer data,
>                                   gulong stack_size,
>                                   gboolean joinable,
>                                   gboolean bound,
>                                   GThreadPriority priority,
>                                   gpointer thread,
>                                   GError **error);
>  void (*thread_yield) (void);
>  void (*thread_join) (gpointer thread);
>  void (*thread_exit) (void);
>  void (*thread_set_priority)(gpointer thread,
>                                   GThreadPriority priority);
>  void (*thread_self) (gpointer thread);
>  gboolean (*thread_equal) (gpointer thread1,
>       gpointer thread2);
>};
>
>extern GThreadFunctions g_thread_functions_for_glib_use;
>extern gboolean g_thread_use_default_impl;
>extern gboolean g_threads_got_initialized;
>
>extern guint64 (*g_thread_gettime) (void);
>
>
>
>
>
>void g_thread_init (GThreadFunctions *vtable);
># 131 "../glib/gthread.h"
>void g_thread_init_with_errorcheck_mutexes (GThreadFunctions* vtable);
># 141 "../glib/gthread.h"
>GMutex* g_static_mutex_get_mutex_impl (GMutex **mutex);
># 212 "../glib/gthread.h"
>GThread* g_thread_create_full (GThreadFunc func,
>                                gpointer data,
>                                gulong stack_size,
>                                gboolean joinable,
>                                gboolean bound,
>                                GThreadPriority priority,
>                                GError **error);
>GThread* g_thread_self (void);
>void g_thread_exit (gpointer retval);
>gpointer g_thread_join (GThread *thread);
>
>void g_thread_set_priority (GThread *thread,
>                                GThreadPriority priority);
># 237 "../glib/gthread.h"
>void g_static_mutex_init (GStaticMutex *mutex);
>void g_static_mutex_free (GStaticMutex *mutex);
>
>struct _GStaticPrivate
>{
>
>  guint index;
>};
>
>void g_static_private_init (GStaticPrivate *private_key);
>gpointer g_static_private_get (GStaticPrivate *private_key);
>void g_static_private_set (GStaticPrivate *private_key,
>       gpointer data,
>       GDestroyNotify notify);
>void g_static_private_free (GStaticPrivate *private_key);
>
>typedef struct _GStaticRecMutex GStaticRecMutex;
>struct _GStaticRecMutex
>{
>
>  GStaticMutex mutex;
>  guint depth;
>  GSystemThread owner;
>};
>
>
>void g_static_rec_mutex_init (GStaticRecMutex *mutex);
>void g_static_rec_mutex_lock (GStaticRecMutex *mutex);
>gboolean g_static_rec_mutex_trylock (GStaticRecMutex *mutex);
>void g_static_rec_mutex_unlock (GStaticRecMutex *mutex);
>void g_static_rec_mutex_lock_full (GStaticRecMutex *mutex,
>                                         guint depth);
>guint g_static_rec_mutex_unlock_full (GStaticRecMutex *mutex);
>void g_static_rec_mutex_free (GStaticRecMutex *mutex);
>
>typedef struct _GStaticRWLock GStaticRWLock;
>struct _GStaticRWLock
>{
>
>  GStaticMutex mutex;
>  GCond *read_cond;
>  GCond *write_cond;
>  guint read_counter;
>  gboolean have_writer;
>  guint want_to_read;
>  guint want_to_write;
>};
>
>
>
>void g_static_rw_lock_init (GStaticRWLock* lock);
>void g_static_rw_lock_reader_lock (GStaticRWLock* lock);
>gboolean g_static_rw_lock_reader_trylock (GStaticRWLock* lock);
>void g_static_rw_lock_reader_unlock (GStaticRWLock* lock);
>void g_static_rw_lock_writer_lock (GStaticRWLock* lock);
>gboolean g_static_rw_lock_writer_trylock (GStaticRWLock* lock);
>void g_static_rw_lock_writer_unlock (GStaticRWLock* lock);
>void g_static_rw_lock_free (GStaticRWLock* lock);
>
>void g_thread_foreach (GFunc thread_func,
>        gpointer user_data);
>
>typedef enum
>{
>  G_ONCE_STATUS_NOTCALLED,
>  G_ONCE_STATUS_PROGRESS,
>  G_ONCE_STATUS_READY
>} GOnceStatus;
>
>typedef struct _GOnce GOnce;
>struct _GOnce
>{
>  volatile GOnceStatus status;
>  volatile gpointer retval;
>};
>
>
>
>gpointer g_once_impl (GOnce *once, GThreadFunc func, gpointer arg);
># 327 "../glib/gthread.h"
>extern inline __attribute__ ((__gnu_inline__)) gboolean g_once_init_enter (volatile gsize *value_location);
>gboolean g_once_init_enter_impl (volatile gsize *value_location);
>void g_once_init_leave (volatile gsize *value_location,
>                                                 gsize initialization_value);
>
>extern inline __attribute__ ((__gnu_inline__)) gboolean
>g_once_init_enter (volatile gsize *value_location)
>{
>  if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (g_atomic_pointer_get ((void*volatile*) value_location) != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1))
>    return (0);
>  else
>    return g_once_init_enter_impl (value_location);
>}
># 351 "../glib/gthread.h"
>extern void glib_dummy_decl (void);
># 394 "../glib/gthread.h"
>
># 31 "../glib/gasyncqueue.h" 2
>
>
>
>typedef struct _GAsyncQueue GAsyncQueue;
>
>
>
>
>GAsyncQueue* g_async_queue_new (void);
>
>GAsyncQueue* g_async_queue_new_full (GDestroyNotify item_free_func);
>
>
>
>
>
>void g_async_queue_lock (GAsyncQueue *queue);
>void g_async_queue_unlock (GAsyncQueue *queue);
>
>
>GAsyncQueue* g_async_queue_ref (GAsyncQueue *queue);
>void g_async_queue_unref (GAsyncQueue *queue);
># 61 "../glib/gasyncqueue.h"
>void g_async_queue_push (GAsyncQueue *queue,
>       gpointer data);
>void g_async_queue_push_unlocked (GAsyncQueue *queue,
>       gpointer data);
>
>void g_async_queue_push_sorted (GAsyncQueue *queue,
>       gpointer data,
>       GCompareDataFunc func,
>       gpointer user_data);
>void g_async_queue_push_sorted_unlocked (GAsyncQueue *queue,
>       gpointer data,
>       GCompareDataFunc func,
>       gpointer user_data);
>
>
>
>
>gpointer g_async_queue_pop (GAsyncQueue *queue);
>gpointer g_async_queue_pop_unlocked (GAsyncQueue *queue);
>
>
>gpointer g_async_queue_try_pop (GAsyncQueue *queue);
>gpointer g_async_queue_try_pop_unlocked (GAsyncQueue *queue);
>
>
>
>
>
>
>gpointer g_async_queue_timed_pop (GAsyncQueue *queue,
>       GTimeVal *end_time);
>gpointer g_async_queue_timed_pop_unlocked (GAsyncQueue *queue,
>       GTimeVal *end_time);
># 102 "../glib/gasyncqueue.h"
>gint g_async_queue_length (GAsyncQueue *queue);
>gint g_async_queue_length_unlocked (GAsyncQueue *queue);
>void g_async_queue_sort (GAsyncQueue *queue,
>       GCompareDataFunc func,
>       gpointer user_data);
>void g_async_queue_sort_unlocked (GAsyncQueue *queue,
>       GCompareDataFunc func,
>       gpointer user_data);
>
>
>GMutex* _g_async_queue_get_mutex (GAsyncQueue *queue);
>
>
># 33 "../glib/glib.h" 2
>
># 1 "../glib/gbacktrace.h" 1
># 32 "../glib/gbacktrace.h"
>
># 43 "../glib/gbacktrace.h"
>void g_on_error_query (const gchar *prg_name);
>void g_on_error_stack_trace (const gchar *prg_name);
># 59 "../glib/gbacktrace.h"
>
># 35 "../glib/glib.h" 2
># 1 "../glib/gbase64.h" 1
># 26 "../glib/gbase64.h"
>
>
>gsize g_base64_encode_step (const guchar *in,
>          gsize len,
>          gboolean break_lines,
>          gchar *out,
>          gint *state,
>          gint *save);
>gsize g_base64_encode_close (gboolean break_lines,
>          gchar *out,
>          gint *state,
>          gint *save);
>gchar* g_base64_encode (const guchar *data,
>          gsize len) __attribute__((__malloc__));
>gsize g_base64_decode_step (const gchar *in,
>          gsize len,
>          guchar *out,
>          gint *state,
>          guint *save);
>guchar *g_base64_decode (const gchar *text,
>          gsize *out_len) __attribute__((__malloc__));
>
>
># 36 "../glib/glib.h" 2
># 1 "../glib/gbookmarkfile.h" 1
># 24 "../glib/gbookmarkfile.h"
># 1 "/usr/include/time.h" 1 3 4
># 31 "/usr/include/time.h" 3 4
>
>
>
>
>
>
>
>
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 40 "/usr/include/time.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 44 "/usr/include/time.h" 2 3 4
># 57 "/usr/include/time.h" 3 4
># 1 "/usr/include/bits/types.h" 1 3 4
># 28 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/bits/types.h" 2 3 4
>
>
>typedef unsigned char __u_char;
>typedef unsigned short int __u_short;
>typedef unsigned int __u_int;
>typedef unsigned long int __u_long;
>
>
>typedef signed char __int8_t;
>typedef unsigned char __uint8_t;
>typedef signed short int __int16_t;
>typedef unsigned short int __uint16_t;
>typedef signed int __int32_t;
>typedef unsigned int __uint32_t;
>
>
>
>
>__extension__ typedef signed long long int __int64_t;
>__extension__ typedef unsigned long long int __uint64_t;
>
>
>
>
>
>
>
>__extension__ typedef long long int __quad_t;
>__extension__ typedef unsigned long long int __u_quad_t;
># 131 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/typesizes.h" 1 3 4
># 132 "/usr/include/bits/types.h" 2 3 4
>
>
>__extension__ typedef __u_quad_t __dev_t;
>__extension__ typedef unsigned int __uid_t;
>__extension__ typedef unsigned int __gid_t;
>__extension__ typedef unsigned long int __ino_t;
>__extension__ typedef __u_quad_t __ino64_t;
>__extension__ typedef unsigned int __mode_t;
>__extension__ typedef unsigned int __nlink_t;
>__extension__ typedef long int __off_t;
>__extension__ typedef __quad_t __off64_t;
>__extension__ typedef int __pid_t;
>__extension__ typedef struct { int __val[2]; } __fsid_t;
>__extension__ typedef long int __clock_t;
>__extension__ typedef unsigned long int __rlim_t;
>__extension__ typedef __u_quad_t __rlim64_t;
>__extension__ typedef unsigned int __id_t;
>__extension__ typedef long int __time_t;
>__extension__ typedef unsigned int __useconds_t;
>__extension__ typedef long int __suseconds_t;
>
>__extension__ typedef int __daddr_t;
>__extension__ typedef long int __swblk_t;
>__extension__ typedef int __key_t;
>
>
>__extension__ typedef int __clockid_t;
>
>
>__extension__ typedef void * __timer_t;
>
>
>__extension__ typedef long int __blksize_t;
>
>
>
>
>__extension__ typedef long int __blkcnt_t;
>__extension__ typedef __quad_t __blkcnt64_t;
>
>
>__extension__ typedef unsigned long int __fsblkcnt_t;
>__extension__ typedef __u_quad_t __fsblkcnt64_t;
>
>
>__extension__ typedef unsigned long int __fsfilcnt_t;
>__extension__ typedef __u_quad_t __fsfilcnt64_t;
>
>__extension__ typedef int __ssize_t;
>
>
>
>typedef __off64_t __loff_t;
>typedef __quad_t *__qaddr_t;
>typedef char *__caddr_t;
>
>
>__extension__ typedef int __intptr_t;
>
>
>__extension__ typedef unsigned int __socklen_t;
># 58 "/usr/include/time.h" 2 3 4
>
>
>
>typedef __clock_t clock_t;
>
>
>
># 75 "/usr/include/time.h" 3 4
>
>
>typedef __time_t time_t;
>
>
>
># 93 "/usr/include/time.h" 3 4
>typedef __clockid_t clockid_t;
># 105 "/usr/include/time.h" 3 4
>typedef __timer_t timer_t;
># 121 "/usr/include/time.h" 3 4
>struct timespec
>  {
>    __time_t tv_sec;
>    long int tv_nsec;
>  };
>
>
>
>
>
>
>
>
>struct tm
>{
>  int tm_sec;
>  int tm_min;
>  int tm_hour;
>  int tm_mday;
>  int tm_mon;
>  int tm_year;
>  int tm_wday;
>  int tm_yday;
>  int tm_isdst;
>
>
>  long int tm_gmtoff;
>  __const char *tm_zone;
>
>
>
>
>};
>
>
>
>
>
>
>
>
>struct itimerspec
>  {
>    struct timespec it_interval;
>    struct timespec it_value;
>  };
>
>
>struct sigevent;
>
>
>
>
>
>typedef __pid_t pid_t;
>
>
>
>
>
>
>
>
>extern clock_t clock (void) __attribute__ ((__nothrow__));
>
>
>extern time_t time (time_t *__timer) __attribute__ ((__nothrow__));
>
>
>extern double difftime (time_t __time1, time_t __time0)
>     __attribute__ ((__nothrow__)) __attribute__ ((__const__));
>
>
>extern time_t mktime (struct tm *__tp) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern size_t strftime (char *__restrict __s, size_t __maxsize,
>   __const char *__restrict __format,
>   __const struct tm *__restrict __tp) __attribute__ ((__nothrow__));
>
># 229 "/usr/include/time.h" 3 4
>
>
>
>extern struct tm *gmtime (__const time_t *__timer) __attribute__ ((__nothrow__));
>
>
>
>extern struct tm *localtime (__const time_t *__timer) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern struct tm *gmtime_r (__const time_t *__restrict __timer,
>       struct tm *__restrict __tp) __attribute__ ((__nothrow__));
>
>
>
>extern struct tm *localtime_r (__const time_t *__restrict __timer,
>          struct tm *__restrict __tp) __attribute__ ((__nothrow__));
>
>
>
>
>
>extern char *asctime (__const struct tm *__tp) __attribute__ ((__nothrow__));
>
>
>extern char *ctime (__const time_t *__timer) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>
>extern char *asctime_r (__const struct tm *__restrict __tp,
>   char *__restrict __buf) __attribute__ ((__nothrow__));
>
>
>extern char *ctime_r (__const time_t *__restrict __timer,
>        char *__restrict __buf) __attribute__ ((__nothrow__));
>
>
>
>
>extern char *__tzname[2];
>extern int __daylight;
>extern long int __timezone;
>
>
>
>
>extern char *tzname[2];
>
>
>
>extern void tzset (void) __attribute__ ((__nothrow__));
>
>
>
>extern int daylight;
>extern long int timezone;
>
>
>
>
>
>extern int stime (__const time_t *__when) __attribute__ ((__nothrow__));
># 312 "/usr/include/time.h" 3 4
>extern time_t timegm (struct tm *__tp) __attribute__ ((__nothrow__));
>
>
>extern time_t timelocal (struct tm *__tp) __attribute__ ((__nothrow__));
>
>
>extern int dysize (int __year) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
># 327 "/usr/include/time.h" 3 4
>extern int nanosleep (__const struct timespec *__requested_time,
>        struct timespec *__remaining);
>
>
>
>extern int clock_getres (clockid_t __clock_id, struct timespec *__res) __attribute__ ((__nothrow__));
>
>
>extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) __attribute__ ((__nothrow__));
>
>
>extern int clock_settime (clockid_t __clock_id, __const struct timespec *__tp)
>     __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern int clock_nanosleep (clockid_t __clock_id, int __flags,
>       __const struct timespec *__req,
>       struct timespec *__rem);
>
>
>extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) __attribute__ ((__nothrow__));
>
>
>
>
>extern int timer_create (clockid_t __clock_id,
>    struct sigevent *__restrict __evp,
>    timer_t *__restrict __timerid) __attribute__ ((__nothrow__));
>
>
>extern int timer_delete (timer_t __timerid) __attribute__ ((__nothrow__));
>
>
>extern int timer_settime (timer_t __timerid, int __flags,
>     __const struct itimerspec *__restrict __value,
>     struct itimerspec *__restrict __ovalue) __attribute__ ((__nothrow__));
>
>
>extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
>     __attribute__ ((__nothrow__));
>
>
>extern int timer_getoverrun (timer_t __timerid) __attribute__ ((__nothrow__));
># 416 "/usr/include/time.h" 3 4
>
># 25 "../glib/gbookmarkfile.h" 2
>
>
>
>
>
>
>
>typedef enum
>{
>  G_BOOKMARK_FILE_ERROR_INVALID_URI,
>  G_BOOKMARK_FILE_ERROR_INVALID_VALUE,
>  G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED,
>  G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND,
>  G_BOOKMARK_FILE_ERROR_READ,
>  G_BOOKMARK_FILE_ERROR_UNKNOWN_ENCODING,
>  G_BOOKMARK_FILE_ERROR_WRITE,
>  G_BOOKMARK_FILE_ERROR_FILE_NOT_FOUND
>} GBookmarkFileError;
>
>GQuark g_bookmark_file_error_quark (void);
>
>
>
>
>typedef struct _GBookmarkFile GBookmarkFile;
>
>GBookmarkFile *g_bookmark_file_new (void);
>void g_bookmark_file_free (GBookmarkFile *bookmark);
>
>gboolean g_bookmark_file_load_from_file (GBookmarkFile *bookmark,
>          const gchar *filename,
>          GError **error);
>gboolean g_bookmark_file_load_from_data (GBookmarkFile *bookmark,
>          const gchar *data,
>          gsize length,
>          GError **error);
>gboolean g_bookmark_file_load_from_data_dirs (GBookmarkFile *bookmark,
>          const gchar *file,
>          gchar **full_path,
>          GError **error);
>gchar * g_bookmark_file_to_data (GBookmarkFile *bookmark,
>          gsize *length,
>          GError **error) __attribute__((__malloc__));
>gboolean g_bookmark_file_to_file (GBookmarkFile *bookmark,
>          const gchar *filename,
>          GError **error);
>
>void g_bookmark_file_set_title (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *title);
>gchar * g_bookmark_file_get_title (GBookmarkFile *bookmark,
>          const gchar *uri,
>          GError **error) __attribute__((__malloc__));
>void g_bookmark_file_set_description (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *description);
>gchar * g_bookmark_file_get_description (GBookmarkFile *bookmark,
>          const gchar *uri,
>          GError **error) __attribute__((__malloc__));
>void g_bookmark_file_set_mime_type (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *mime_type);
>gchar * g_bookmark_file_get_mime_type (GBookmarkFile *bookmark,
>          const gchar *uri,
>          GError **error) __attribute__((__malloc__));
>void g_bookmark_file_set_groups (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar **groups,
>          gsize length);
>void g_bookmark_file_add_group (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *group);
>gboolean g_bookmark_file_has_group (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *group,
>          GError **error);
>gchar ** g_bookmark_file_get_groups (GBookmarkFile *bookmark,
>          const gchar *uri,
>          gsize *length,
>          GError **error) __attribute__((__malloc__));
>void g_bookmark_file_add_application (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *name,
>          const gchar *exec);
>gboolean g_bookmark_file_has_application (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *name,
>          GError **error);
>gchar ** g_bookmark_file_get_applications (GBookmarkFile *bookmark,
>          const gchar *uri,
>          gsize *length,
>          GError **error) __attribute__((__malloc__));
>gboolean g_bookmark_file_set_app_info (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *name,
>          const gchar *exec,
>          gint count,
>          time_t stamp,
>          GError **error);
>gboolean g_bookmark_file_get_app_info (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *name,
>          gchar **exec,
>          guint *count,
>          time_t *stamp,
>          GError **error);
>void g_bookmark_file_set_is_private (GBookmarkFile *bookmark,
>          const gchar *uri,
>          gboolean is_private);
>gboolean g_bookmark_file_get_is_private (GBookmarkFile *bookmark,
>          const gchar *uri,
>          GError **error);
>void g_bookmark_file_set_icon (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *href,
>          const gchar *mime_type);
>gboolean g_bookmark_file_get_icon (GBookmarkFile *bookmark,
>          const gchar *uri,
>          gchar **href,
>          gchar **mime_type,
>          GError **error);
>void g_bookmark_file_set_added (GBookmarkFile *bookmark,
>          const gchar *uri,
>          time_t added);
>time_t g_bookmark_file_get_added (GBookmarkFile *bookmark,
>          const gchar *uri,
>          GError **error);
>void g_bookmark_file_set_modified (GBookmarkFile *bookmark,
>          const gchar *uri,
>          time_t modified);
>time_t g_bookmark_file_get_modified (GBookmarkFile *bookmark,
>          const gchar *uri,
>          GError **error);
>void g_bookmark_file_set_visited (GBookmarkFile *bookmark,
>          const gchar *uri,
>          time_t visited);
>time_t g_bookmark_file_get_visited (GBookmarkFile *bookmark,
>          const gchar *uri,
>          GError **error);
>gboolean g_bookmark_file_has_item (GBookmarkFile *bookmark,
>          const gchar *uri);
>gint g_bookmark_file_get_size (GBookmarkFile *bookmark);
>gchar ** g_bookmark_file_get_uris (GBookmarkFile *bookmark,
>          gsize *length) __attribute__((__malloc__));
>gboolean g_bookmark_file_remove_group (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *group,
>          GError **error);
>gboolean g_bookmark_file_remove_application (GBookmarkFile *bookmark,
>          const gchar *uri,
>          const gchar *name,
>          GError **error);
>gboolean g_bookmark_file_remove_item (GBookmarkFile *bookmark,
>          const gchar *uri,
>          GError **error);
>gboolean g_bookmark_file_move_item (GBookmarkFile *bookmark,
>          const gchar *old_uri,
>          const gchar *new_uri,
>          GError **error);
>
>
># 37 "../glib/glib.h" 2
># 1 "../glib/gcache.h" 1
># 30 "../glib/gcache.h"
># 1 "../glib/glist.h" 1
># 30 "../glib/glist.h"
># 1 "../glib/gmem.h" 1
># 30 "../glib/gmem.h"
># 1 "../glib/gslice.h" 1
># 28 "../glib/gslice.h"
>
>
>
>
>gpointer g_slice_alloc (gsize block_size) __attribute__((__malloc__));
>gpointer g_slice_alloc0 (gsize block_size) __attribute__((__malloc__));
>gpointer g_slice_copy (gsize block_size,
>                                         gconstpointer mem_block) __attribute__((__malloc__));
>void g_slice_free1 (gsize block_size,
>      gpointer mem_block);
>void g_slice_free_chain_with_offset (gsize block_size,
>      gpointer mem_chain,
>      gsize next_offset);
># 70 "../glib/gslice.h"
>typedef enum {
>  G_SLICE_CONFIG_ALWAYS_MALLOC = 1,
>  G_SLICE_CONFIG_BYPASS_MAGAZINES,
>  G_SLICE_CONFIG_WORKING_SET_MSECS,
>  G_SLICE_CONFIG_COLOR_INCREMENT,
>  G_SLICE_CONFIG_CHUNK_SIZES,
>  G_SLICE_CONFIG_CONTENTION_COUNTER
>} GSliceConfig;
>void g_slice_set_config (GSliceConfig ckey, gint64 value);
>gint64 g_slice_get_config (GSliceConfig ckey);
>gint64* g_slice_get_config_state (GSliceConfig ckey, gint64 address, guint *n_values);
>
>
># 31 "../glib/gmem.h" 2
>
>
>
>
>typedef struct _GMemVTable GMemVTable;
># 47 "../glib/gmem.h"
>gpointer g_malloc (gsize n_bytes) __attribute__((__malloc__));
>gpointer g_malloc0 (gsize n_bytes) __attribute__((__malloc__));
>gpointer g_realloc (gpointer mem,
>      gsize n_bytes) __attribute__((warn_unused_result));
>void g_free (gpointer mem);
>gpointer g_try_malloc (gsize n_bytes) __attribute__((__malloc__));
>gpointer g_try_malloc0 (gsize n_bytes) __attribute__((__malloc__));
>gpointer g_try_realloc (gpointer mem,
>      gsize n_bytes) __attribute__((warn_unused_result));
># 79 "../glib/gmem.h"
>struct _GMemVTable
>{
>  gpointer (*malloc) (gsize n_bytes);
>  gpointer (*realloc) (gpointer mem,
>      gsize n_bytes);
>  void (*free) (gpointer mem);
>
>  gpointer (*calloc) (gsize n_blocks,
>      gsize n_block_bytes);
>  gpointer (*try_malloc) (gsize n_bytes);
>  gpointer (*try_realloc) (gpointer mem,
>      gsize n_bytes);
>};
>void g_mem_set_vtable (GMemVTable *vtable);
>gboolean g_mem_is_system_malloc (void);
>
>extern gboolean g_mem_gc_friendly;
>
>
>
>extern GMemVTable *glib_mem_profiler_table;
>void g_mem_profile (void);
># 146 "../glib/gmem.h"
>
># 31 "../glib/glist.h" 2
>
>
>
>typedef struct _GList GList;
>
>struct _GList
>{
>  gpointer data;
>  GList *next;
>  GList *prev;
>};
>
>
>
>GList* g_list_alloc (void) __attribute__((warn_unused_result));
>void g_list_free (GList *list);
>void g_list_free_1 (GList *list);
>
>GList* g_list_append (GList *list,
>      gpointer data) __attribute__((warn_unused_result));
>GList* g_list_prepend (GList *list,
>      gpointer data) __attribute__((warn_unused_result));
>GList* g_list_insert (GList *list,
>      gpointer data,
>      gint position) __attribute__((warn_unused_result));
>GList* g_list_insert_sorted (GList *list,
>      gpointer data,
>      GCompareFunc func) __attribute__((warn_unused_result));
>GList* g_list_insert_sorted_with_data (GList *list,
>      gpointer data,
>      GCompareDataFunc func,
>      gpointer user_data) __attribute__((warn_unused_result));
>GList* g_list_insert_before (GList *list,
>      GList *sibling,
>      gpointer data) __attribute__((warn_unused_result));
>GList* g_list_concat (GList *list1,
>      GList *list2) __attribute__((warn_unused_result));
>GList* g_list_remove (GList *list,
>      gconstpointer data) __attribute__((warn_unused_result));
>GList* g_list_remove_all (GList *list,
>      gconstpointer data) __attribute__((warn_unused_result));
>GList* g_list_remove_link (GList *list,
>      GList *llink) __attribute__((warn_unused_result));
>GList* g_list_delete_link (GList *list,
>      GList *link_) __attribute__((warn_unused_result));
>GList* g_list_reverse (GList *list) __attribute__((warn_unused_result));
>GList* g_list_copy (GList *list) __attribute__((warn_unused_result));
>GList* g_list_nth (GList *list,
>      guint n);
>GList* g_list_nth_prev (GList *list,
>      guint n);
>GList* g_list_find (GList *list,
>      gconstpointer data);
>GList* g_list_find_custom (GList *list,
>      gconstpointer data,
>      GCompareFunc func);
>gint g_list_position (GList *list,
>      GList *llink);
>gint g_list_index (GList *list,
>      gconstpointer data);
>GList* g_list_last (GList *list);
>GList* g_list_first (GList *list);
>guint g_list_length (GList *list);
>void g_list_foreach (GList *list,
>      GFunc func,
>      gpointer user_data);
>GList* g_list_sort (GList *list,
>      GCompareFunc compare_func) __attribute__((warn_unused_result));
>GList* g_list_sort_with_data (GList *list,
>      GCompareDataFunc compare_func,
>      gpointer user_data) __attribute__((warn_unused_result));
>gpointer g_list_nth_data (GList *list,
>      guint n);
># 113 "../glib/glist.h"
>
># 31 "../glib/gcache.h" 2
>
>
>
>typedef struct _GCache GCache;
>
>typedef gpointer (*GCacheNewFunc) (gpointer key);
>typedef gpointer (*GCacheDupFunc) (gpointer value);
>typedef void (*GCacheDestroyFunc) (gpointer value);
>
>
>
>GCache* g_cache_new (GCacheNewFunc value_new_func,
>                                GCacheDestroyFunc value_destroy_func,
>                                GCacheDupFunc key_dup_func,
>                                GCacheDestroyFunc key_destroy_func,
>                                GHashFunc hash_key_func,
>                                GHashFunc hash_value_func,
>                                GEqualFunc key_equal_func);
>void g_cache_destroy (GCache *cache);
>gpointer g_cache_insert (GCache *cache,
>                                gpointer key);
>void g_cache_remove (GCache *cache,
>                                gconstpointer value);
>void g_cache_key_foreach (GCache *cache,
>                                GHFunc func,
>                                gpointer user_data);
>
>
>
>
>
>
>
># 38 "../glib/glib.h" 2
># 1 "../glib/gchecksum.h" 1
># 26 "../glib/gchecksum.h"
>
># 42 "../glib/gchecksum.h"
>typedef enum {
>  G_CHECKSUM_MD5,
>  G_CHECKSUM_SHA1,
>  G_CHECKSUM_SHA256
>} GChecksumType;
>
>typedef struct _GChecksum GChecksum;
>
>gssize g_checksum_type_get_length (GChecksumType checksum_type);
>
>GChecksum * g_checksum_new (GChecksumType checksum_type);
>GChecksum * g_checksum_copy (const GChecksum *checksum);
>void g_checksum_free (GChecksum *checksum);
>void g_checksum_update (GChecksum *checksum,
>                                             const guchar *data,
>                                             gssize length);
> gchar *g_checksum_get_string (GChecksum *checksum);
>void g_checksum_get_digest (GChecksum *checksum,
>                                             guint8 *buffer,
>                                             gsize *digest_len);
>
>gchar *g_compute_checksum_for_data (GChecksumType checksum_type,
>                                      const guchar *data,
>                                      gsize length);
>gchar *g_compute_checksum_for_string (GChecksumType checksum_type,
>                                      const gchar *str,
>                                      gssize length);
>
>
># 39 "../glib/glib.h" 2
># 1 "../glib/gcompletion.h" 1
># 32 "../glib/gcompletion.h"
>
>
>typedef struct _GCompletion GCompletion;
>
>typedef gchar* (*GCompletionFunc) (gpointer);
>
>
>
>
>typedef gint (*GCompletionStrncmpFunc) (const gchar *s1,
>     const gchar *s2,
>     gsize n);
>
>struct _GCompletion
>{
>  GList* items;
>  GCompletionFunc func;
>
>  gchar* prefix;
>  GList* cache;
>  GCompletionStrncmpFunc strncmp_func;
>};
>
>GCompletion* g_completion_new (GCompletionFunc func);
>void g_completion_add_items (GCompletion* cmp,
>                                         GList* items);
>void g_completion_remove_items (GCompletion* cmp,
>                                         GList* items);
>void g_completion_clear_items (GCompletion* cmp);
>GList* g_completion_complete (GCompletion* cmp,
>                                         const gchar* prefix,
>                                         gchar** new_prefix);
>GList* g_completion_complete_utf8 (GCompletion *cmp,
>                                         const gchar* prefix,
>                                         gchar** new_prefix);
>void g_completion_set_compare (GCompletion *cmp,
>             GCompletionStrncmpFunc strncmp_func);
>void g_completion_free (GCompletion* cmp);
>
>
># 40 "../glib/glib.h" 2
># 1 "../glib/gconvert.h" 1
># 32 "../glib/gconvert.h"
>
>
>typedef enum
>{
>  G_CONVERT_ERROR_NO_CONVERSION,
>  G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
>  G_CONVERT_ERROR_FAILED,
>  G_CONVERT_ERROR_PARTIAL_INPUT,
>  G_CONVERT_ERROR_BAD_URI,
>  G_CONVERT_ERROR_NOT_ABSOLUTE_PATH
>} GConvertError;
>
>
>GQuark g_convert_error_quark (void);
>
>
>
>typedef struct _GIConv *GIConv;
>
>GIConv g_iconv_open (const gchar *to_codeset,
>         const gchar *from_codeset);
>gsize g_iconv (GIConv converter,
>         gchar **inbuf,
>         gsize *inbytes_left,
>         gchar **outbuf,
>         gsize *outbytes_left);
>gint g_iconv_close (GIConv converter);
>
>
>gchar* g_convert (const gchar *str,
>    gssize len,
>    const gchar *to_codeset,
>    const gchar *from_codeset,
>    gsize *bytes_read,
>    gsize *bytes_written,
>    GError **error) __attribute__((__malloc__));
>gchar* g_convert_with_iconv (const gchar *str,
>    gssize len,
>    GIConv converter,
>    gsize *bytes_read,
>    gsize *bytes_written,
>    GError **error) __attribute__((__malloc__));
>gchar* g_convert_with_fallback (const gchar *str,
>    gssize len,
>    const gchar *to_codeset,
>    const gchar *from_codeset,
>    gchar *fallback,
>    gsize *bytes_read,
>    gsize *bytes_written,
>    GError **error) __attribute__((__malloc__));
>
>
>
>
>gchar* g_locale_to_utf8 (const gchar *opsysstring,
>      gssize len,
>      gsize *bytes_read,
>      gsize *bytes_written,
>      GError **error) __attribute__((__malloc__));
>gchar* g_locale_from_utf8 (const gchar *utf8string,
>      gssize len,
>      gsize *bytes_read,
>      gsize *bytes_written,
>      GError **error) __attribute__((__malloc__));
># 107 "../glib/gconvert.h"
>gchar* g_filename_to_utf8 (const gchar *opsysstring,
>        gssize len,
>        gsize *bytes_read,
>        gsize *bytes_written,
>        GError **error) __attribute__((__malloc__));
>gchar* g_filename_from_utf8 (const gchar *utf8string,
>        gssize len,
>        gsize *bytes_read,
>        gsize *bytes_written,
>        GError **error) __attribute__((__malloc__));
>
>gchar *g_filename_from_uri (const gchar *uri,
>       gchar **hostname,
>       GError **error) __attribute__((__malloc__));
>
>gchar *g_filename_to_uri (const gchar *filename,
>       const gchar *hostname,
>       GError **error) __attribute__((__malloc__));
>gchar *g_filename_display_name (const gchar *filename) __attribute__((__malloc__));
>gboolean g_get_filename_charsets ( gchar ***charsets);
>
>gchar *g_filename_display_basename (const gchar *filename) __attribute__((__malloc__));
>
>gchar **g_uri_list_extract_uris (const gchar *uri_list) __attribute__((__malloc__));
>
>
># 41 "../glib/glib.h" 2
># 1 "../glib/gdataset.h" 1
># 32 "../glib/gdataset.h"
>
>
>typedef struct _GData GData;
>
>typedef void (*GDataForeachFunc) (GQuark key_id,
>                                                 gpointer data,
>                                                 gpointer user_data);
>
>
>
>void g_datalist_init (GData **datalist);
>void g_datalist_clear (GData **datalist);
>gpointer g_datalist_id_get_data (GData **datalist,
>      GQuark key_id);
>void g_datalist_id_set_data_full (GData **datalist,
>      GQuark key_id,
>      gpointer data,
>      GDestroyNotify destroy_func);
>gpointer g_datalist_id_remove_no_notify (GData **datalist,
>      GQuark key_id);
>void g_datalist_foreach (GData **datalist,
>      GDataForeachFunc func,
>      gpointer user_data);
># 65 "../glib/gdataset.h"
>void g_datalist_set_flags (GData **datalist,
>      guint flags);
>void g_datalist_unset_flags (GData **datalist,
>      guint flags);
>guint g_datalist_get_flags (GData **datalist);
># 89 "../glib/gdataset.h"
>void g_dataset_destroy (gconstpointer dataset_location);
>gpointer g_dataset_id_get_data (gconstpointer dataset_location,
>                                         GQuark key_id);
>void g_dataset_id_set_data_full (gconstpointer dataset_location,
>                                         GQuark key_id,
>                                         gpointer data,
>                                         GDestroyNotify destroy_func);
>gpointer g_dataset_id_remove_no_notify (gconstpointer dataset_location,
>                                         GQuark key_id);
>void g_dataset_foreach (gconstpointer dataset_location,
>                                         GDataForeachFunc func,
>                                         gpointer user_data);
># 116 "../glib/gdataset.h"
>
># 42 "../glib/glib.h" 2
># 1 "../glib/gdate.h" 1
># 35 "../glib/gdate.h"
>
># 46 "../glib/gdate.h"
>typedef gint32 GTime;
>typedef guint16 GDateYear;
>typedef guint8 GDateDay;
>typedef struct _GDate GDate;
>
>
>typedef enum
>{
>  G_DATE_DAY = 0,
>  G_DATE_MONTH = 1,
>  G_DATE_YEAR = 2
>} GDateDMY;
>
>
>typedef enum
>{
>  G_DATE_BAD_WEEKDAY = 0,
>  G_DATE_MONDAY = 1,
>  G_DATE_TUESDAY = 2,
>  G_DATE_WEDNESDAY = 3,
>  G_DATE_THURSDAY = 4,
>  G_DATE_FRIDAY = 5,
>  G_DATE_SATURDAY = 6,
>  G_DATE_SUNDAY = 7
>} GDateWeekday;
>typedef enum
>{
>  G_DATE_BAD_MONTH = 0,
>  G_DATE_JANUARY = 1,
>  G_DATE_FEBRUARY = 2,
>  G_DATE_MARCH = 3,
>  G_DATE_APRIL = 4,
>  G_DATE_MAY = 5,
>  G_DATE_JUNE = 6,
>  G_DATE_JULY = 7,
>  G_DATE_AUGUST = 8,
>  G_DATE_SEPTEMBER = 9,
>  G_DATE_OCTOBER = 10,
>  G_DATE_NOVEMBER = 11,
>  G_DATE_DECEMBER = 12
>} GDateMonth;
># 97 "../glib/gdate.h"
>struct _GDate
>{
>  guint julian_days : 32;
>
>
>
>
>
>  guint julian : 1;
>  guint dmy : 1;
>
>
>  guint day : 6;
>  guint month : 4;
>  guint year : 16;
>};
>
>
>
>
>
>GDate* g_date_new (void);
>GDate* g_date_new_dmy (GDateDay day,
>                                           GDateMonth month,
>                                           GDateYear year);
>GDate* g_date_new_julian (guint32 julian_day);
>void g_date_free (GDate *date);
>
>
>
>
>
>
>gboolean g_date_valid (const GDate *date);
>gboolean g_date_valid_day (GDateDay day) __attribute__((__const__));
>gboolean g_date_valid_month (GDateMonth month) __attribute__((__const__));
>gboolean g_date_valid_year (GDateYear year) __attribute__((__const__));
>gboolean g_date_valid_weekday (GDateWeekday weekday) __attribute__((__const__));
>gboolean g_date_valid_julian (guint32 julian_date) __attribute__((__const__));
>gboolean g_date_valid_dmy (GDateDay day,
>                                           GDateMonth month,
>                                           GDateYear year) __attribute__((__const__));
>
>GDateWeekday g_date_get_weekday (const GDate *date);
>GDateMonth g_date_get_month (const GDate *date);
>GDateYear g_date_get_year (const GDate *date);
>GDateDay g_date_get_day (const GDate *date);
>guint32 g_date_get_julian (const GDate *date);
>guint g_date_get_day_of_year (const GDate *date);
>
>
>
>
>
>
>guint g_date_get_monday_week_of_year (const GDate *date);
>guint g_date_get_sunday_week_of_year (const GDate *date);
>guint g_date_get_iso8601_week_of_year (const GDate *date);
>
>
>
>
>
>void g_date_clear (GDate *date,
>                                           guint n_dates);
>
>
>
>
>
>void g_date_set_parse (GDate *date,
>                                           const gchar *str);
>void g_date_set_time_t (GDate *date,
>        time_t timet);
>void g_date_set_time_val (GDate *date,
>        GTimeVal *timeval);
>
>
>
>
>void g_date_set_month (GDate *date,
>                                           GDateMonth month);
>void g_date_set_day (GDate *date,
>                                           GDateDay day);
>void g_date_set_year (GDate *date,
>                                           GDateYear year);
>void g_date_set_dmy (GDate *date,
>                                           GDateDay day,
>                                           GDateMonth month,
>                                           GDateYear y);
>void g_date_set_julian (GDate *date,
>                                           guint32 julian_date);
>gboolean g_date_is_first_of_month (const GDate *date);
>gboolean g_date_is_last_of_month (const GDate *date);
>
>
>void g_date_add_days (GDate *date,
>                                           guint n_days);
>void g_date_subtract_days (GDate *date,
>                                           guint n_days);
>
>
>void g_date_add_months (GDate *date,
>                                           guint n_months);
>void g_date_subtract_months (GDate *date,
>                                           guint n_months);
>
>
>void g_date_add_years (GDate *date,
>                                           guint n_years);
>void g_date_subtract_years (GDate *date,
>                                           guint n_years);
>gboolean g_date_is_leap_year (GDateYear year) __attribute__((__const__));
>guint8 g_date_get_days_in_month (GDateMonth month,
>                                           GDateYear year) __attribute__((__const__));
>guint8 g_date_get_monday_weeks_in_year (GDateYear year) __attribute__((__const__));
>guint8 g_date_get_sunday_weeks_in_year (GDateYear year) __attribute__((__const__));
>
>
>
>gint g_date_days_between (const GDate *date1,
>        const GDate *date2);
>
>
>gint g_date_compare (const GDate *lhs,
>                                           const GDate *rhs);
>void g_date_to_struct_tm (const GDate *date,
>                                           struct tm *tm);
>
>void g_date_clamp (GDate *date,
>        const GDate *min_date,
>        const GDate *max_date);
>
>
>void g_date_order (GDate *date1, GDate *date2);
>
>
>
>
>gsize g_date_strftime (gchar *s,
>                                           gsize slen,
>                                           const gchar *format,
>                                           const GDate *date);
># 257 "../glib/gdate.h"
>
># 43 "../glib/glib.h" 2
># 1 "../glib/gdir.h" 1
># 28 "../glib/gdir.h"
>
>
>typedef struct _GDir GDir;
>
>
>
>
>
>
>
>GDir * g_dir_open (const gchar *path,
>            guint flags,
>            GError **error);
> gchar *g_dir_read_name (GDir *dir);
>void g_dir_rewind (GDir *dir);
>void g_dir_close (GDir *dir);
>
>
># 44 "../glib/glib.h" 2
>
># 1 "../glib/gfileutils.h" 1
># 26 "../glib/gfileutils.h"
>
>
>
>
>typedef enum
>{
>  G_FILE_ERROR_EXIST,
>  G_FILE_ERROR_ISDIR,
>  G_FILE_ERROR_ACCES,
>  G_FILE_ERROR_NAMETOOLONG,
>  G_FILE_ERROR_NOENT,
>  G_FILE_ERROR_NOTDIR,
>  G_FILE_ERROR_NXIO,
>  G_FILE_ERROR_NODEV,
>  G_FILE_ERROR_ROFS,
>  G_FILE_ERROR_TXTBSY,
>  G_FILE_ERROR_FAULT,
>  G_FILE_ERROR_LOOP,
>  G_FILE_ERROR_NOSPC,
>  G_FILE_ERROR_NOMEM,
>  G_FILE_ERROR_MFILE,
>  G_FILE_ERROR_NFILE,
>  G_FILE_ERROR_BADF,
>  G_FILE_ERROR_INVAL,
>  G_FILE_ERROR_PIPE,
>  G_FILE_ERROR_AGAIN,
>  G_FILE_ERROR_INTR,
>  G_FILE_ERROR_IO,
>  G_FILE_ERROR_PERM,
>  G_FILE_ERROR_NOSYS,
>  G_FILE_ERROR_FAILED
>} GFileError;
>
>
>
>
>
>typedef enum
>{
>  G_FILE_TEST_IS_REGULAR = 1 << 0,
>  G_FILE_TEST_IS_SYMLINK = 1 << 1,
>  G_FILE_TEST_IS_DIR = 1 << 2,
>  G_FILE_TEST_IS_EXECUTABLE = 1 << 3,
>  G_FILE_TEST_EXISTS = 1 << 4
>} GFileTest;
>
>GQuark g_file_error_quark (void);
>
>GFileError g_file_error_from_errno (gint err_no);
># 83 "../glib/gfileutils.h"
>gboolean g_file_test (const gchar *filename,
>                              GFileTest test);
>gboolean g_file_get_contents (const gchar *filename,
>                              gchar **contents,
>                              gsize *length,
>                              GError **error);
>gboolean g_file_set_contents (const gchar *filename,
>         const gchar *contents,
>         gssize length,
>         GError **error);
>gchar *g_file_read_link (const gchar *filename,
>         GError **error);
>
>
>gint g_mkstemp (gchar *tmpl);
>
>
>gint g_file_open_tmp (const gchar *tmpl,
>         gchar **name_used,
>         GError **error);
>
>char *g_format_size_for_display (goffset size);
>
>gchar *g_build_path (const gchar *separator,
>    const gchar *first_element,
>    ...) __attribute__((__malloc__)) __attribute__((__sentinel__));
>gchar *g_build_pathv (const gchar *separator,
>    gchar **args) __attribute__((__malloc__));
>
>gchar *g_build_filename (const gchar *first_element,
>    ...) __attribute__((__malloc__)) __attribute__((__sentinel__));
>gchar *g_build_filenamev (gchar **args) __attribute__((__malloc__));
>
>int g_mkdir_with_parents (const gchar *pathname,
>        int mode);
>
>
># 46 "../glib/glib.h" 2
># 1 "../glib/ghash.h" 1
># 33 "../glib/ghash.h"
>
>
>typedef struct _GHashTable GHashTable;
>
>typedef gboolean (*GHRFunc) (gpointer key,
>                               gpointer value,
>                               gpointer user_data);
>
>typedef struct _GHashTableIter GHashTableIter;
>
>struct _GHashTableIter
>{
>
>  gpointer dummy1;
>  gpointer dummy2;
>  gpointer dummy3;
>  int dummy4;
>  gboolean dummy5;
>  gpointer dummy6;
>};
>
>
>
>GHashTable* g_hash_table_new (GHashFunc hash_func,
>         GEqualFunc key_equal_func);
>GHashTable* g_hash_table_new_full (GHashFunc hash_func,
>         GEqualFunc key_equal_func,
>         GDestroyNotify key_destroy_func,
>         GDestroyNotify value_destroy_func);
>void g_hash_table_destroy (GHashTable *hash_table);
>void g_hash_table_insert (GHashTable *hash_table,
>         gpointer key,
>         gpointer value);
>void g_hash_table_replace (GHashTable *hash_table,
>         gpointer key,
>         gpointer value);
>gboolean g_hash_table_remove (GHashTable *hash_table,
>         gconstpointer key);
>void g_hash_table_remove_all (GHashTable *hash_table);
>gboolean g_hash_table_steal (GHashTable *hash_table,
>         gconstpointer key);
>void g_hash_table_steal_all (GHashTable *hash_table);
>gpointer g_hash_table_lookup (GHashTable *hash_table,
>         gconstpointer key);
>gboolean g_hash_table_lookup_extended (GHashTable *hash_table,
>         gconstpointer lookup_key,
>         gpointer *orig_key,
>         gpointer *value);
>void g_hash_table_foreach (GHashTable *hash_table,
>         GHFunc func,
>         gpointer user_data);
>gpointer g_hash_table_find (GHashTable *hash_table,
>         GHRFunc predicate,
>         gpointer user_data);
>guint g_hash_table_foreach_remove (GHashTable *hash_table,
>         GHRFunc func,
>         gpointer user_data);
>guint g_hash_table_foreach_steal (GHashTable *hash_table,
>         GHRFunc func,
>         gpointer user_data);
>guint g_hash_table_size (GHashTable *hash_table);
>GList * g_hash_table_get_keys (GHashTable *hash_table);
>GList * g_hash_table_get_values (GHashTable *hash_table);
>
>void g_hash_table_iter_init (GHashTableIter *iter,
>         GHashTable *hash_table);
>gboolean g_hash_table_iter_next (GHashTableIter *iter,
>         gpointer *key,
>         gpointer *value);
>GHashTable* g_hash_table_iter_get_hash_table (GHashTableIter *iter);
>void g_hash_table_iter_remove (GHashTableIter *iter);
>void g_hash_table_iter_steal (GHashTableIter *iter);
>
>
>GHashTable* g_hash_table_ref (GHashTable *hash_table);
>void g_hash_table_unref (GHashTable *hash_table);
># 121 "../glib/ghash.h"
>gboolean g_str_equal (gconstpointer v1,
>                      gconstpointer v2);
>guint g_str_hash (gconstpointer v);
>
>gboolean g_int_equal (gconstpointer v1,
>                      gconstpointer v2);
>guint g_int_hash (gconstpointer v);
>
>
>
>
>
>
>
>guint g_direct_hash (gconstpointer v) __attribute__((__const__));
>gboolean g_direct_equal (gconstpointer v1,
>                         gconstpointer v2) __attribute__((__const__));
>
>
># 47 "../glib/glib.h" 2
># 1 "../glib/ghook.h" 1
># 32 "../glib/ghook.h"
>
>
>
>
>typedef struct _GHook GHook;
>typedef struct _GHookList GHookList;
>
>typedef gint (*GHookCompareFunc) (GHook *new_hook,
>       GHook *sibling);
>typedef gboolean (*GHookFindFunc) (GHook *hook,
>       gpointer data);
>typedef void (*GHookMarshaller) (GHook *hook,
>       gpointer marshal_data);
>typedef gboolean (*GHookCheckMarshaller) (GHook *hook,
>       gpointer marshal_data);
>typedef void (*GHookFunc) (gpointer data);
>typedef gboolean (*GHookCheckFunc) (gpointer data);
>typedef void (*GHookFinalizeFunc) (GHookList *hook_list,
>       GHook *hook);
>typedef enum
>{
>  G_HOOK_FLAG_ACTIVE = 1 << 0,
>  G_HOOK_FLAG_IN_CALL = 1 << 1,
>  G_HOOK_FLAG_MASK = 0x0f
>} GHookFlagMask;
>
>
>
>
>struct _GHookList
>{
>  gulong seq_id;
>  guint hook_size : 16;
>  guint is_setup : 1;
>  GHook *hooks;
>  gpointer dummy3;
>  GHookFinalizeFunc finalize_hook;
>  gpointer dummy[2];
>};
>struct _GHook
>{
>  gpointer data;
>  GHook *next;
>  GHook *prev;
>  guint ref_count;
>  gulong hook_id;
>  guint flags;
>  gpointer func;
>  GDestroyNotify destroy;
>};
># 102 "../glib/ghook.h"
>void g_hook_list_init (GHookList *hook_list,
>      guint hook_size);
>void g_hook_list_clear (GHookList *hook_list);
>GHook* g_hook_alloc (GHookList *hook_list);
>void g_hook_free (GHookList *hook_list,
>      GHook *hook);
>GHook * g_hook_ref (GHookList *hook_list,
>      GHook *hook);
>void g_hook_unref (GHookList *hook_list,
>      GHook *hook);
>gboolean g_hook_destroy (GHookList *hook_list,
>      gulong hook_id);
>void g_hook_destroy_link (GHookList *hook_list,
>      GHook *hook);
>void g_hook_prepend (GHookList *hook_list,
>      GHook *hook);
>void g_hook_insert_before (GHookList *hook_list,
>      GHook *sibling,
>      GHook *hook);
>void g_hook_insert_sorted (GHookList *hook_list,
>      GHook *hook,
>      GHookCompareFunc func);
>GHook* g_hook_get (GHookList *hook_list,
>      gulong hook_id);
>GHook* g_hook_find (GHookList *hook_list,
>      gboolean need_valids,
>      GHookFindFunc func,
>      gpointer data);
>GHook* g_hook_find_data (GHookList *hook_list,
>      gboolean need_valids,
>      gpointer data);
>GHook* g_hook_find_func (GHookList *hook_list,
>      gboolean need_valids,
>      gpointer func);
>GHook* g_hook_find_func_data (GHookList *hook_list,
>      gboolean need_valids,
>      gpointer func,
>      gpointer data);
>
>GHook* g_hook_first_valid (GHookList *hook_list,
>      gboolean may_be_in_call);
>
>
>
>GHook* g_hook_next_valid (GHookList *hook_list,
>      GHook *hook,
>      gboolean may_be_in_call);
>
>gint g_hook_compare_ids (GHook *new_hook,
>      GHook *sibling);
>
>
>
>
>
>void g_hook_list_invoke (GHookList *hook_list,
>      gboolean may_recurse);
>
>
>
>void g_hook_list_invoke_check (GHookList *hook_list,
>      gboolean may_recurse);
>
>
>void g_hook_list_marshal (GHookList *hook_list,
>      gboolean may_recurse,
>      GHookMarshaller marshaller,
>      gpointer marshal_data);
>void g_hook_list_marshal_check (GHookList *hook_list,
>      gboolean may_recurse,
>      GHookCheckMarshaller marshaller,
>      gpointer marshal_data);
>
>
># 48 "../glib/glib.h" 2
># 1 "../glib/giochannel.h" 1
># 31 "../glib/giochannel.h"
># 1 "../glib/gmain.h" 1
># 23 "../glib/gmain.h"
># 1 "../glib/gslist.h" 1
># 32 "../glib/gslist.h"
>
>
>typedef struct _GSList GSList;
>
>struct _GSList
>{
>  gpointer data;
>  GSList *next;
>};
>
>
>
>GSList* g_slist_alloc (void) __attribute__((warn_unused_result));
>void g_slist_free (GSList *list);
>void g_slist_free_1 (GSList *list);
>
>GSList* g_slist_append (GSList *list,
>       gpointer data) __attribute__((warn_unused_result));
>GSList* g_slist_prepend (GSList *list,
>       gpointer data) __attribute__((warn_unused_result));
>GSList* g_slist_insert (GSList *list,
>       gpointer data,
>       gint position) __attribute__((warn_unused_result));
>GSList* g_slist_insert_sorted (GSList *list,
>       gpointer data,
>       GCompareFunc func) __attribute__((warn_unused_result));
>GSList* g_slist_insert_sorted_with_data (GSList *list,
>       gpointer data,
>       GCompareDataFunc func,
>       gpointer user_data) __attribute__((warn_unused_result));
>GSList* g_slist_insert_before (GSList *slist,
>       GSList *sibling,
>       gpointer data) __attribute__((warn_unused_result));
>GSList* g_slist_concat (GSList *list1,
>       GSList *list2) __attribute__((warn_unused_result));
>GSList* g_slist_remove (GSList *list,
>       gconstpointer data) __attribute__((warn_unused_result));
>GSList* g_slist_remove_all (GSList *list,
>       gconstpointer data) __attribute__((warn_unused_result));
>GSList* g_slist_remove_link (GSList *list,
>       GSList *link_) __attribute__((warn_unused_result));
>GSList* g_slist_delete_link (GSList *list,
>       GSList *link_) __attribute__((warn_unused_result));
>GSList* g_slist_reverse (GSList *list) __attribute__((warn_unused_result));
>GSList* g_slist_copy (GSList *list) __attribute__((warn_unused_result));
>GSList* g_slist_nth (GSList *list,
>       guint n);
>GSList* g_slist_find (GSList *list,
>       gconstpointer data);
>GSList* g_slist_find_custom (GSList *list,
>       gconstpointer data,
>       GCompareFunc func);
>gint g_slist_position (GSList *list,
>       GSList *llink);
>gint g_slist_index (GSList *list,
>       gconstpointer data);
>GSList* g_slist_last (GSList *list);
>guint g_slist_length (GSList *list);
>void g_slist_foreach (GSList *list,
>       GFunc func,
>       gpointer user_data);
>GSList* g_slist_sort (GSList *list,
>       GCompareFunc compare_func) __attribute__((warn_unused_result));
>GSList* g_slist_sort_with_data (GSList *list,
>       GCompareDataFunc compare_func,
>       gpointer user_data) __attribute__((warn_unused_result));
>gpointer g_slist_nth_data (GSList *list,
>       guint n);
>
>
>
>
>
>
>
>
># 24 "../glib/gmain.h" 2
>
>
>
>
>typedef struct _GMainContext GMainContext;
>typedef struct _GMainLoop GMainLoop;
>typedef struct _GSource GSource;
>typedef struct _GSourceCallbackFuncs GSourceCallbackFuncs;
>typedef struct _GSourceFuncs GSourceFuncs;
>
>typedef gboolean (*GSourceFunc) (gpointer data);
>typedef void (*GChildWatchFunc) (GPid pid,
>           gint status,
>           gpointer data);
>struct _GSource
>{
>
>  gpointer callback_data;
>  GSourceCallbackFuncs *callback_funcs;
>
>  GSourceFuncs *source_funcs;
>  guint ref_count;
>
>  GMainContext *context;
>
>  gint priority;
>  guint flags;
>  guint source_id;
>
>  GSList *poll_fds;
>
>  GSource *prev;
>  GSource *next;
>
>  gpointer reserved1;
>  gpointer reserved2;
>};
>
>struct _GSourceCallbackFuncs
>{
>  void (*ref) (gpointer cb_data);
>  void (*unref) (gpointer cb_data);
>  void (*get) (gpointer cb_data,
>   GSource *source,
>   GSourceFunc *func,
>   gpointer *data);
>};
>
>typedef void (*GSourceDummyMarshal) (void);
>
>struct _GSourceFuncs
>{
>  gboolean (*prepare) (GSource *source,
>   gint *timeout_);
>  gboolean (*check) (GSource *source);
>  gboolean (*dispatch) (GSource *source,
>   GSourceFunc callback,
>   gpointer user_data);
>  void (*finalize) (GSource *source);
>
>
>  GSourceFunc closure_callback;
>  GSourceDummyMarshal closure_marshal;
>};
># 116 "../glib/gmain.h"
>typedef struct _GPollFD GPollFD;
>typedef gint (*GPollFunc) (GPollFD *ufds,
>     guint nfsd,
>     gint timeout_);
>
>struct _GPollFD
>{
>
>
>
>  gint fd;
>
>  gushort events;
>  gushort revents;
>};
># 142 "../glib/gmain.h"
>GMainContext *g_main_context_new (void);
>GMainContext *g_main_context_ref (GMainContext *context);
>void g_main_context_unref (GMainContext *context);
>GMainContext *g_main_context_default (void);
>
>gboolean g_main_context_iteration (GMainContext *context,
>     gboolean may_block);
>gboolean g_main_context_pending (GMainContext *context);
>
>
>
>GSource *g_main_context_find_source_by_id (GMainContext *context,
>            guint source_id);
>GSource *g_main_context_find_source_by_user_data (GMainContext *context,
>            gpointer user_data);
>GSource *g_main_context_find_source_by_funcs_user_data (GMainContext *context,
>             GSourceFuncs *funcs,
>            gpointer user_data);
>
>
>
>void g_main_context_wakeup (GMainContext *context);
>gboolean g_main_context_acquire (GMainContext *context);
>void g_main_context_release (GMainContext *context);
>gboolean g_main_context_is_owner (GMainContext *context);
>gboolean g_main_context_wait (GMainContext *context,
>     GCond *cond,
>     GMutex *mutex);
>
>gboolean g_main_context_prepare (GMainContext *context,
>      gint *priority);
>gint g_main_context_query (GMainContext *context,
>      gint max_priority,
>      gint *timeout_,
>      GPollFD *fds,
>      gint n_fds);
>gint g_main_context_check (GMainContext *context,
>      gint max_priority,
>      GPollFD *fds,
>      gint n_fds);
>void g_main_context_dispatch (GMainContext *context);
>
>void g_main_context_set_poll_func (GMainContext *context,
>           GPollFunc func);
>GPollFunc g_main_context_get_poll_func (GMainContext *context);
>
>
>
>void g_main_context_add_poll (GMainContext *context,
>         GPollFD *fd,
>         gint priority);
>void g_main_context_remove_poll (GMainContext *context,
>         GPollFD *fd);
>
>gint g_main_depth (void);
>GSource *g_main_current_source (void);
>
>
>
>
>GMainLoop *g_main_loop_new (GMainContext *context,
>           gboolean is_running);
>void g_main_loop_run (GMainLoop *loop);
>void g_main_loop_quit (GMainLoop *loop);
>GMainLoop *g_main_loop_ref (GMainLoop *loop);
>void g_main_loop_unref (GMainLoop *loop);
>gboolean g_main_loop_is_running (GMainLoop *loop);
>GMainContext *g_main_loop_get_context (GMainLoop *loop);
>
>
>
>GSource *g_source_new (GSourceFuncs *source_funcs,
>       guint struct_size);
>GSource *g_source_ref (GSource *source);
>void g_source_unref (GSource *source);
>
>guint g_source_attach (GSource *source,
>       GMainContext *context);
>void g_source_destroy (GSource *source);
>
>void g_source_set_priority (GSource *source,
>       gint priority);
>gint g_source_get_priority (GSource *source);
>void g_source_set_can_recurse (GSource *source,
>       gboolean can_recurse);
>gboolean g_source_get_can_recurse (GSource *source);
>guint g_source_get_id (GSource *source);
>
>GMainContext *g_source_get_context (GSource *source);
>
>void g_source_set_callback (GSource *source,
>       GSourceFunc func,
>       gpointer data,
>       GDestroyNotify notify);
>
>void g_source_set_funcs (GSource *source,
>                                   GSourceFuncs *funcs);
>gboolean g_source_is_destroyed (GSource *source);
>
>
>void g_source_set_callback_indirect (GSource *source,
>         gpointer callback_data,
>         GSourceCallbackFuncs *callback_funcs);
>
>void g_source_add_poll (GSource *source,
>        GPollFD *fd);
>void g_source_remove_poll (GSource *source,
>        GPollFD *fd);
>
>void g_source_get_current_time (GSource *source,
>        GTimeVal *timeval);
>
>
>
>
>
>
>
>GSource *g_idle_source_new (void);
>GSource *g_child_watch_source_new (GPid pid);
>GSource *g_timeout_source_new (guint interval);
>GSource *g_timeout_source_new_seconds (guint interval);
>
>
>
>void g_get_current_time (GTimeVal *result);
># 292 "../glib/gmain.h"
>gboolean g_source_remove (guint tag);
>gboolean g_source_remove_by_user_data (gpointer user_data);
>gboolean g_source_remove_by_funcs_user_data (GSourceFuncs *funcs,
>           gpointer user_data);
>
>
>guint g_timeout_add_full (gint priority,
>         guint interval,
>         GSourceFunc function,
>         gpointer data,
>         GDestroyNotify notify);
>guint g_timeout_add (guint interval,
>         GSourceFunc function,
>         gpointer data);
>guint g_timeout_add_seconds_full (gint priority,
>                                     guint interval,
>                                     GSourceFunc function,
>                                     gpointer data,
>                                     GDestroyNotify notify);
>guint g_timeout_add_seconds (guint interval,
>         GSourceFunc function,
>         gpointer data);
>guint g_child_watch_add_full (gint priority,
>         GPid pid,
>         GChildWatchFunc function,
>         gpointer data,
>         GDestroyNotify notify);
>guint g_child_watch_add (GPid pid,
>         GChildWatchFunc function,
>         gpointer data);
>guint g_idle_add (GSourceFunc function,
>         gpointer data);
>guint g_idle_add_full (gint priority,
>         GSourceFunc function,
>         gpointer data,
>         GDestroyNotify notify);
>gboolean g_idle_remove_by_data (gpointer data);
>
>
>extern GSourceFuncs g_timeout_funcs;
>extern GSourceFuncs g_child_watch_funcs;
>extern GSourceFuncs g_idle_funcs;
>
>
># 32 "../glib/giochannel.h" 2
># 1 "../glib/gstring.h" 1
># 31 "../glib/gstring.h"
># 1 "../glib/gunicode.h" 1
># 28 "../glib/gunicode.h"
>
>
>typedef guint32 gunichar;
>typedef guint16 gunichar2;
>
>
>
>
>typedef enum
>{
>  G_UNICODE_CONTROL,
>  G_UNICODE_FORMAT,
>  G_UNICODE_UNASSIGNED,
>  G_UNICODE_PRIVATE_USE,
>  G_UNICODE_SURROGATE,
>  G_UNICODE_LOWERCASE_LETTER,
>  G_UNICODE_MODIFIER_LETTER,
>  G_UNICODE_OTHER_LETTER,
>  G_UNICODE_TITLECASE_LETTER,
>  G_UNICODE_UPPERCASE_LETTER,
>  G_UNICODE_COMBINING_MARK,
>  G_UNICODE_ENCLOSING_MARK,
>  G_UNICODE_NON_SPACING_MARK,
>  G_UNICODE_DECIMAL_NUMBER,
>  G_UNICODE_LETTER_NUMBER,
>  G_UNICODE_OTHER_NUMBER,
>  G_UNICODE_CONNECT_PUNCTUATION,
>  G_UNICODE_DASH_PUNCTUATION,
>  G_UNICODE_CLOSE_PUNCTUATION,
>  G_UNICODE_FINAL_PUNCTUATION,
>  G_UNICODE_INITIAL_PUNCTUATION,
>  G_UNICODE_OTHER_PUNCTUATION,
>  G_UNICODE_OPEN_PUNCTUATION,
>  G_UNICODE_CURRENCY_SYMBOL,
>  G_UNICODE_MODIFIER_SYMBOL,
>  G_UNICODE_MATH_SYMBOL,
>  G_UNICODE_OTHER_SYMBOL,
>  G_UNICODE_LINE_SEPARATOR,
>  G_UNICODE_PARAGRAPH_SEPARATOR,
>  G_UNICODE_SPACE_SEPARATOR
>} GUnicodeType;
>
>
>
>
>
>
>typedef enum
>{
>  G_UNICODE_BREAK_MANDATORY,
>  G_UNICODE_BREAK_CARRIAGE_RETURN,
>  G_UNICODE_BREAK_LINE_FEED,
>  G_UNICODE_BREAK_COMBINING_MARK,
>  G_UNICODE_BREAK_SURROGATE,
>  G_UNICODE_BREAK_ZERO_WIDTH_SPACE,
>  G_UNICODE_BREAK_INSEPARABLE,
>  G_UNICODE_BREAK_NON_BREAKING_GLUE,
>  G_UNICODE_BREAK_CONTINGENT,
>  G_UNICODE_BREAK_SPACE,
>  G_UNICODE_BREAK_AFTER,
>  G_UNICODE_BREAK_BEFORE,
>  G_UNICODE_BREAK_BEFORE_AND_AFTER,
>  G_UNICODE_BREAK_HYPHEN,
>  G_UNICODE_BREAK_NON_STARTER,
>  G_UNICODE_BREAK_OPEN_PUNCTUATION,
>  G_UNICODE_BREAK_CLOSE_PUNCTUATION,
>  G_UNICODE_BREAK_QUOTATION,
>  G_UNICODE_BREAK_EXCLAMATION,
>  G_UNICODE_BREAK_IDEOGRAPHIC,
>  G_UNICODE_BREAK_NUMERIC,
>  G_UNICODE_BREAK_INFIX_SEPARATOR,
>  G_UNICODE_BREAK_SYMBOL,
>  G_UNICODE_BREAK_ALPHABETIC,
>  G_UNICODE_BREAK_PREFIX,
>  G_UNICODE_BREAK_POSTFIX,
>  G_UNICODE_BREAK_COMPLEX_CONTEXT,
>  G_UNICODE_BREAK_AMBIGUOUS,
>  G_UNICODE_BREAK_UNKNOWN,
>  G_UNICODE_BREAK_NEXT_LINE,
>  G_UNICODE_BREAK_WORD_JOINER,
>  G_UNICODE_BREAK_HANGUL_L_JAMO,
>  G_UNICODE_BREAK_HANGUL_V_JAMO,
>  G_UNICODE_BREAK_HANGUL_T_JAMO,
>  G_UNICODE_BREAK_HANGUL_LV_SYLLABLE,
>  G_UNICODE_BREAK_HANGUL_LVT_SYLLABLE
>} GUnicodeBreakType;
>
>typedef enum
>{
>  G_UNICODE_SCRIPT_INVALID_CODE = -1,
>  G_UNICODE_SCRIPT_COMMON = 0,
>  G_UNICODE_SCRIPT_INHERITED,
>  G_UNICODE_SCRIPT_ARABIC,
>  G_UNICODE_SCRIPT_ARMENIAN,
>  G_UNICODE_SCRIPT_BENGALI,
>  G_UNICODE_SCRIPT_BOPOMOFO,
>  G_UNICODE_SCRIPT_CHEROKEE,
>  G_UNICODE_SCRIPT_COPTIC,
>  G_UNICODE_SCRIPT_CYRILLIC,
>  G_UNICODE_SCRIPT_DESERET,
>  G_UNICODE_SCRIPT_DEVANAGARI,
>  G_UNICODE_SCRIPT_ETHIOPIC,
>  G_UNICODE_SCRIPT_GEORGIAN,
>  G_UNICODE_SCRIPT_GOTHIC,
>  G_UNICODE_SCRIPT_GREEK,
>  G_UNICODE_SCRIPT_GUJARATI,
>  G_UNICODE_SCRIPT_GURMUKHI,
>  G_UNICODE_SCRIPT_HAN,
>  G_UNICODE_SCRIPT_HANGUL,
>  G_UNICODE_SCRIPT_HEBREW,
>  G_UNICODE_SCRIPT_HIRAGANA,
>  G_UNICODE_SCRIPT_KANNADA,
>  G_UNICODE_SCRIPT_KATAKANA,
>  G_UNICODE_SCRIPT_KHMER,
>  G_UNICODE_SCRIPT_LAO,
>  G_UNICODE_SCRIPT_LATIN,
>  G_UNICODE_SCRIPT_MALAYALAM,
>  G_UNICODE_SCRIPT_MONGOLIAN,
>  G_UNICODE_SCRIPT_MYANMAR,
>  G_UNICODE_SCRIPT_OGHAM,
>  G_UNICODE_SCRIPT_OLD_ITALIC,
>  G_UNICODE_SCRIPT_ORIYA,
>  G_UNICODE_SCRIPT_RUNIC,
>  G_UNICODE_SCRIPT_SINHALA,
>  G_UNICODE_SCRIPT_SYRIAC,
>  G_UNICODE_SCRIPT_TAMIL,
>  G_UNICODE_SCRIPT_TELUGU,
>  G_UNICODE_SCRIPT_THAANA,
>  G_UNICODE_SCRIPT_THAI,
>  G_UNICODE_SCRIPT_TIBETAN,
>  G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL,
>  G_UNICODE_SCRIPT_YI,
>  G_UNICODE_SCRIPT_TAGALOG,
>  G_UNICODE_SCRIPT_HANUNOO,
>  G_UNICODE_SCRIPT_BUHID,
>  G_UNICODE_SCRIPT_TAGBANWA,
>
>
>  G_UNICODE_SCRIPT_BRAILLE,
>  G_UNICODE_SCRIPT_CYPRIOT,
>  G_UNICODE_SCRIPT_LIMBU,
>  G_UNICODE_SCRIPT_OSMANYA,
>  G_UNICODE_SCRIPT_SHAVIAN,
>  G_UNICODE_SCRIPT_LINEAR_B,
>  G_UNICODE_SCRIPT_TAI_LE,
>  G_UNICODE_SCRIPT_UGARITIC,
>
>
>  G_UNICODE_SCRIPT_NEW_TAI_LUE,
>  G_UNICODE_SCRIPT_BUGINESE,
>  G_UNICODE_SCRIPT_GLAGOLITIC,
>  G_UNICODE_SCRIPT_TIFINAGH,
>  G_UNICODE_SCRIPT_SYLOTI_NAGRI,
>  G_UNICODE_SCRIPT_OLD_PERSIAN,
>  G_UNICODE_SCRIPT_KHAROSHTHI,
>
>
>  G_UNICODE_SCRIPT_UNKNOWN,
>  G_UNICODE_SCRIPT_BALINESE,
>  G_UNICODE_SCRIPT_CUNEIFORM,
>  G_UNICODE_SCRIPT_PHOENICIAN,
>  G_UNICODE_SCRIPT_PHAGS_PA,
>  G_UNICODE_SCRIPT_NKO,
>
>
>  G_UNICODE_SCRIPT_KAYAH_LI,
>  G_UNICODE_SCRIPT_LEPCHA,
>  G_UNICODE_SCRIPT_REJANG,
>  G_UNICODE_SCRIPT_SUNDANESE,
>  G_UNICODE_SCRIPT_SAURASHTRA,
>  G_UNICODE_SCRIPT_CHAM,
>  G_UNICODE_SCRIPT_OL_CHIKI,
>  G_UNICODE_SCRIPT_VAI,
>  G_UNICODE_SCRIPT_CARIAN,
>  G_UNICODE_SCRIPT_LYCIAN,
>  G_UNICODE_SCRIPT_LYDIAN
>} GUnicodeScript;
>
>
>
>
>
>
>
>gboolean g_get_charset ( char **charset);
>
>
>
>gboolean g_unichar_isalnum (gunichar c) __attribute__((__const__));
>gboolean g_unichar_isalpha (gunichar c) __attribute__((__const__));
>gboolean g_unichar_iscntrl (gunichar c) __attribute__((__const__));
>gboolean g_unichar_isdigit (gunichar c) __attribute__((__const__));
>gboolean g_unichar_isgraph (gunichar c) __attribute__((__const__));
>gboolean g_unichar_islower (gunichar c) __attribute__((__const__));
>gboolean g_unichar_isprint (gunichar c) __attribute__((__const__));
>gboolean g_unichar_ispunct (gunichar c) __attribute__((__const__));
>gboolean g_unichar_isspace (gunichar c) __attribute__((__const__));
>gboolean g_unichar_isupper (gunichar c) __attribute__((__const__));
>gboolean g_unichar_isxdigit (gunichar c) __attribute__((__const__));
>gboolean g_unichar_istitle (gunichar c) __attribute__((__const__));
>gboolean g_unichar_isdefined (gunichar c) __attribute__((__const__));
>gboolean g_unichar_iswide (gunichar c) __attribute__((__const__));
>gboolean g_unichar_iswide_cjk(gunichar c) __attribute__((__const__));
>gboolean g_unichar_iszerowidth(gunichar c) __attribute__((__const__));
>gboolean g_unichar_ismark (gunichar c) __attribute__((__const__));
>
>
>
>gunichar g_unichar_toupper (gunichar c) __attribute__((__const__));
>gunichar g_unichar_tolower (gunichar c) __attribute__((__const__));
>gunichar g_unichar_totitle (gunichar c) __attribute__((__const__));
>
>
>
>gint g_unichar_digit_value (gunichar c) __attribute__((__const__));
>
>gint g_unichar_xdigit_value (gunichar c) __attribute__((__const__));
>
>
>GUnicodeType g_unichar_type (gunichar c) __attribute__((__const__));
>
>
>GUnicodeBreakType g_unichar_break_type (gunichar c) __attribute__((__const__));
>
>
>gint g_unichar_combining_class (gunichar uc) __attribute__((__const__));
>
>
>
>
>
>void g_unicode_canonical_ordering (gunichar *string,
>       gsize len);
>
>
>
>
>gunichar *g_unicode_canonical_decomposition (gunichar ch,
>          gsize *result_len) __attribute__((__malloc__));
>
>
>
>extern const gchar * const g_utf8_skip;
>
>
>
>gunichar g_utf8_get_char (const gchar *p) __attribute__((__pure__));
>gunichar g_utf8_get_char_validated (const gchar *p,
>        gssize max_len) __attribute__((__pure__));
>
>gchar* g_utf8_offset_to_pointer (const gchar *str,
>                                   glong offset) __attribute__((__pure__));
>glong g_utf8_pointer_to_offset (const gchar *str,
>       const gchar *pos) __attribute__((__pure__));
>gchar* g_utf8_prev_char (const gchar *p) __attribute__((__pure__));
>gchar* g_utf8_find_next_char (const gchar *p,
>       const gchar *end) __attribute__((__pure__));
>gchar* g_utf8_find_prev_char (const gchar *str,
>       const gchar *p) __attribute__((__pure__));
>
>glong g_utf8_strlen (const gchar *p,
>       gssize max) __attribute__((__pure__));
>
>
>gchar* g_utf8_strncpy (gchar *dest,
>         const gchar *src,
>         gsize n);
>
>
>
>gchar* g_utf8_strchr (const gchar *p,
>         gssize len,
>         gunichar c);
>gchar* g_utf8_strrchr (const gchar *p,
>         gssize len,
>         gunichar c);
>gchar* g_utf8_strreverse (const gchar *str,
>     gssize len);
>
>gunichar2 *g_utf8_to_utf16 (const gchar *str,
>    glong len,
>    glong *items_read,
>    glong *items_written,
>    GError **error) __attribute__((__malloc__));
>gunichar * g_utf8_to_ucs4 (const gchar *str,
>    glong len,
>    glong *items_read,
>    glong *items_written,
>    GError **error) __attribute__((__malloc__));
>gunichar * g_utf8_to_ucs4_fast (const gchar *str,
>    glong len,
>    glong *items_written) __attribute__((__malloc__));
>gunichar * g_utf16_to_ucs4 (const gunichar2 *str,
>    glong len,
>    glong *items_read,
>    glong *items_written,
>    GError **error) __attribute__((__malloc__));
>gchar* g_utf16_to_utf8 (const gunichar2 *str,
>    glong len,
>    glong *items_read,
>    glong *items_written,
>    GError **error) __attribute__((__malloc__));
>gunichar2 *g_ucs4_to_utf16 (const gunichar *str,
>    glong len,
>    glong *items_read,
>    glong *items_written,
>    GError **error) __attribute__((__malloc__));
>gchar* g_ucs4_to_utf8 (const gunichar *str,
>    glong len,
>    glong *items_read,
>    glong *items_written,
>    GError **error) __attribute__((__malloc__));
>
>
>
>
>
>gint g_unichar_to_utf8 (gunichar c,
>        gchar *outbuf);
>
>
>
>
>
>gboolean g_utf8_validate (const gchar *str,
>                          gssize max_len,
>                          const gchar **end);
>
>
>gboolean g_unichar_validate (gunichar ch) __attribute__((__const__));
>
>gchar *g_utf8_strup (const gchar *str,
>         gssize len) __attribute__((__malloc__));
>gchar *g_utf8_strdown (const gchar *str,
>         gssize len) __attribute__((__malloc__));
>gchar *g_utf8_casefold (const gchar *str,
>   gssize len) __attribute__((__malloc__));
>
>typedef enum {
>  G_NORMALIZE_DEFAULT,
>  G_NORMALIZE_NFD = G_NORMALIZE_DEFAULT,
>  G_NORMALIZE_DEFAULT_COMPOSE,
>  G_NORMALIZE_NFC = G_NORMALIZE_DEFAULT_COMPOSE,
>  G_NORMALIZE_ALL,
>  G_NORMALIZE_NFKD = G_NORMALIZE_ALL,
>  G_NORMALIZE_ALL_COMPOSE,
>  G_NORMALIZE_NFKC = G_NORMALIZE_ALL_COMPOSE
>} GNormalizeMode;
>
>gchar *g_utf8_normalize (const gchar *str,
>    gssize len,
>    GNormalizeMode mode) __attribute__((__malloc__));
>
>gint g_utf8_collate (const gchar *str1,
>      const gchar *str2) __attribute__((__pure__));
>gchar *g_utf8_collate_key (const gchar *str,
>      gssize len) __attribute__((__malloc__));
>gchar *g_utf8_collate_key_for_filename (const gchar *str,
>                   gssize len) __attribute__((__malloc__));
>
>gboolean g_unichar_get_mirror_char (gunichar ch,
>                                    gunichar *mirrored_ch);
>
>GUnicodeScript g_unichar_get_script (gunichar ch) __attribute__((__const__));
>
>
>
>
>gchar *_g_utf8_make_valid (const gchar *name);
>
>
>
># 32 "../glib/gstring.h" 2
>
>
>
>
>typedef struct _GString GString;
>typedef struct _GStringChunk GStringChunk;
>
>struct _GString
>{
>  gchar *str;
>  gsize len;
>  gsize allocated_len;
>};
>
>
>
>GStringChunk* g_string_chunk_new (gsize size);
>void g_string_chunk_free (GStringChunk *chunk);
>void g_string_chunk_clear (GStringChunk *chunk);
>gchar* g_string_chunk_insert (GStringChunk *chunk,
>         const gchar *string);
>gchar* g_string_chunk_insert_len (GStringChunk *chunk,
>         const gchar *string,
>         gssize len);
>gchar* g_string_chunk_insert_const (GStringChunk *chunk,
>         const gchar *string);
>
>
>
>
>GString* g_string_new (const gchar *init);
>GString* g_string_new_len (const gchar *init,
>                                         gssize len);
>GString* g_string_sized_new (gsize dfl_size);
>gchar* g_string_free (GString *string,
>      gboolean free_segment);
>gboolean g_string_equal (const GString *v,
>      const GString *v2);
>guint g_string_hash (const GString *str);
>GString* g_string_assign (GString *string,
>      const gchar *rval);
>GString* g_string_truncate (GString *string,
>      gsize len);
>GString* g_string_set_size (GString *string,
>      gsize len);
>GString* g_string_insert_len (GString *string,
>                                         gssize pos,
>                                         const gchar *val,
>                                         gssize len);
>GString* g_string_append (GString *string,
>                    const gchar *val);
>GString* g_string_append_len (GString *string,
>                    const gchar *val,
>                                         gssize len);
>GString* g_string_append_c (GString *string,
>      gchar c);
>GString* g_string_append_unichar (GString *string,
>      gunichar wc);
>GString* g_string_prepend (GString *string,
>      const gchar *val);
>GString* g_string_prepend_c (GString *string,
>      gchar c);
>GString* g_string_prepend_unichar (GString *string,
>      gunichar wc);
>GString* g_string_prepend_len (GString *string,
>                    const gchar *val,
>                                         gssize len);
>GString* g_string_insert (GString *string,
>      gssize pos,
>      const gchar *val);
>GString* g_string_insert_c (GString *string,
>      gssize pos,
>      gchar c);
>GString* g_string_insert_unichar (GString *string,
>      gssize pos,
>      gunichar wc);
>GString* g_string_overwrite (GString *string,
>      gsize pos,
>      const gchar *val);
>GString* g_string_overwrite_len (GString *string,
>      gsize pos,
>      const gchar *val,
>      gssize len);
>GString* g_string_erase (GString *string,
>      gssize pos,
>      gssize len);
>GString* g_string_ascii_down (GString *string);
>GString* g_string_ascii_up (GString *string);
>void g_string_vprintf (GString *string,
>      const gchar *format,
>      va_list args);
>void g_string_printf (GString *string,
>      const gchar *format,
>      ...) __attribute__((__format__ (__printf__, 2, 3)));
>void g_string_append_vprintf (GString *string,
>      const gchar *format,
>      va_list args);
>void g_string_append_printf (GString *string,
>      const gchar *format,
>      ...) __attribute__((__format__ (__printf__, 2, 3)));
>GString * g_string_append_uri_escaped(GString *string,
>      const char *unescaped,
>      const char *reserved_chars_allowed,
>      gboolean allow_utf8);
>
>
>
>static inline GString*
>g_string_append_c_inline (GString *gstring,
>                          gchar c)
>{
>  if (gstring->len + 1 < gstring->allocated_len)
>    {
>      gstring->str[gstring->len++] = c;
>      gstring->str[gstring->len] = 0;
>    }
>  else
>    g_string_insert_c (gstring, -1, c);
>  return gstring;
>}
># 172 "../glib/gstring.h"
>
># 33 "../glib/giochannel.h" 2
>
>
>
>
>
>
>typedef struct _GIOChannel GIOChannel;
>typedef struct _GIOFuncs GIOFuncs;
>
>typedef enum
>{
>  G_IO_ERROR_NONE,
>  G_IO_ERROR_AGAIN,
>  G_IO_ERROR_INVAL,
>  G_IO_ERROR_UNKNOWN
>} GIOError;
>
>
>
>typedef enum
>{
>
>  G_IO_CHANNEL_ERROR_FBIG,
>  G_IO_CHANNEL_ERROR_INVAL,
>  G_IO_CHANNEL_ERROR_IO,
>  G_IO_CHANNEL_ERROR_ISDIR,
>  G_IO_CHANNEL_ERROR_NOSPC,
>  G_IO_CHANNEL_ERROR_NXIO,
>  G_IO_CHANNEL_ERROR_OVERFLOW,
>  G_IO_CHANNEL_ERROR_PIPE,
>
>  G_IO_CHANNEL_ERROR_FAILED
>} GIOChannelError;
>
>typedef enum
>{
>  G_IO_STATUS_ERROR,
>  G_IO_STATUS_NORMAL,
>  G_IO_STATUS_EOF,
>  G_IO_STATUS_AGAIN
>} GIOStatus;
>
>typedef enum
>{
>  G_SEEK_CUR,
>  G_SEEK_SET,
>  G_SEEK_END
>} GSeekType;
>
>typedef enum
>{
>  G_IO_IN =1,
>  G_IO_OUT =4,
>  G_IO_PRI =2,
>  G_IO_ERR =8,
>  G_IO_HUP =16,
>  G_IO_NVAL =32
>} GIOCondition;
>
>typedef enum
>{
>  G_IO_FLAG_APPEND = 1 << 0,
>  G_IO_FLAG_NONBLOCK = 1 << 1,
>  G_IO_FLAG_IS_READABLE = 1 << 2,
>  G_IO_FLAG_IS_WRITEABLE = 1 << 3,
>  G_IO_FLAG_IS_SEEKABLE = 1 << 4,
>  G_IO_FLAG_MASK = (1 << 5) - 1,
>  G_IO_FLAG_GET_MASK = G_IO_FLAG_MASK,
>  G_IO_FLAG_SET_MASK = G_IO_FLAG_APPEND | G_IO_FLAG_NONBLOCK
>} GIOFlags;
>
>struct _GIOChannel
>{
>
>  gint ref_count;
>  GIOFuncs *funcs;
>
>  gchar *encoding;
>  GIConv read_cd;
>  GIConv write_cd;
>  gchar *line_term;
>  guint line_term_len;
>
>  gsize buf_size;
>  GString *read_buf;
>  GString *encoded_read_buf;
>  GString *write_buf;
>  gchar partial_write_buf[6];
>
>
>
>  guint use_buffer : 1;
>  guint do_encode : 1;
>  guint close_on_unref : 1;
>  guint is_readable : 1;
>  guint is_writeable : 1;
>  guint is_seekable : 1;
>
>  gpointer reserved1;
>  gpointer reserved2;
>};
>
>typedef gboolean (*GIOFunc) (GIOChannel *source,
>        GIOCondition condition,
>        gpointer data);
>struct _GIOFuncs
>{
>  GIOStatus (*io_read) (GIOChannel *channel,
>             gchar *buf,
>      gsize count,
>      gsize *bytes_read,
>      GError **err);
>  GIOStatus (*io_write) (GIOChannel *channel,
>      const gchar *buf,
>      gsize count,
>      gsize *bytes_written,
>      GError **err);
>  GIOStatus (*io_seek) (GIOChannel *channel,
>      gint64 offset,
>      GSeekType type,
>      GError **err);
>  GIOStatus (*io_close) (GIOChannel *channel,
>      GError **err);
>  GSource* (*io_create_watch) (GIOChannel *channel,
>      GIOCondition condition);
>  void (*io_free) (GIOChannel *channel);
>  GIOStatus (*io_set_flags) (GIOChannel *channel,
>                                  GIOFlags flags,
>      GError **err);
>  GIOFlags (*io_get_flags) (GIOChannel *channel);
>};
>
>void g_io_channel_init (GIOChannel *channel);
>GIOChannel *g_io_channel_ref (GIOChannel *channel);
>void g_io_channel_unref (GIOChannel *channel);
># 184 "../glib/giochannel.h"
>GIOStatus g_io_channel_shutdown (GIOChannel *channel,
>     gboolean flush,
>     GError **err);
>guint g_io_add_watch_full (GIOChannel *channel,
>     gint priority,
>     GIOCondition condition,
>     GIOFunc func,
>     gpointer user_data,
>     GDestroyNotify notify);
>GSource * g_io_create_watch (GIOChannel *channel,
>     GIOCondition condition);
>guint g_io_add_watch (GIOChannel *channel,
>     GIOCondition condition,
>     GIOFunc func,
>     gpointer user_data);
>
>
>
>
>void g_io_channel_set_buffer_size (GIOChannel *channel,
>        gsize size);
>gsize g_io_channel_get_buffer_size (GIOChannel *channel);
>GIOCondition g_io_channel_get_buffer_condition (GIOChannel *channel);
>GIOStatus g_io_channel_set_flags (GIOChannel *channel,
>        GIOFlags flags,
>        GError **error);
>GIOFlags g_io_channel_get_flags (GIOChannel *channel);
>void g_io_channel_set_line_term (GIOChannel *channel,
>        const gchar *line_term,
>        gint length);
> gchar* g_io_channel_get_line_term (GIOChannel *channel,
>        gint *length);
>void g_io_channel_set_buffered (GIOChannel *channel,
>        gboolean buffered);
>gboolean g_io_channel_get_buffered (GIOChannel *channel);
>GIOStatus g_io_channel_set_encoding (GIOChannel *channel,
>        const gchar *encoding,
>        GError **error);
> gchar* g_io_channel_get_encoding (GIOChannel *channel);
>void g_io_channel_set_close_on_unref (GIOChannel *channel,
>        gboolean do_close);
>gboolean g_io_channel_get_close_on_unref (GIOChannel *channel);
>
>
>GIOStatus g_io_channel_flush (GIOChannel *channel,
>        GError **error);
>GIOStatus g_io_channel_read_line (GIOChannel *channel,
>        gchar **str_return,
>        gsize *length,
>        gsize *terminator_pos,
>        GError **error);
>GIOStatus g_io_channel_read_line_string (GIOChannel *channel,
>        GString *buffer,
>        gsize *terminator_pos,
>        GError **error);
>GIOStatus g_io_channel_read_to_end (GIOChannel *channel,
>        gchar **str_return,
>        gsize *length,
>        GError **error);
>GIOStatus g_io_channel_read_chars (GIOChannel *channel,
>        gchar *buf,
>        gsize count,
>        gsize *bytes_read,
>        GError **error);
>GIOStatus g_io_channel_read_unichar (GIOChannel *channel,
>        gunichar *thechar,
>        GError **error);
>GIOStatus g_io_channel_write_chars (GIOChannel *channel,
>        const gchar *buf,
>        gssize count,
>        gsize *bytes_written,
>        GError **error);
>GIOStatus g_io_channel_write_unichar (GIOChannel *channel,
>        gunichar thechar,
>        GError **error);
>GIOStatus g_io_channel_seek_position (GIOChannel *channel,
>        gint64 offset,
>        GSeekType type,
>        GError **error);
>
>
>
>
>GIOChannel* g_io_channel_new_file (const gchar *filename,
>        const gchar *mode,
>        GError **error);
>
>
>
>GQuark g_io_channel_error_quark (void);
>GIOChannelError g_io_channel_error_from_errno (gint en);
># 294 "../glib/giochannel.h"
>GIOChannel* g_io_channel_unix_new (int fd);
>gint g_io_channel_unix_get_fd (GIOChannel *channel);
>
>
>
>extern GSourceFuncs g_io_watch_funcs;
># 352 "../glib/giochannel.h"
>
># 49 "../glib/glib.h" 2
># 1 "../glib/gkeyfile.h" 1
># 28 "../glib/gkeyfile.h"
>
>
>typedef enum
>{
>  G_KEY_FILE_ERROR_UNKNOWN_ENCODING,
>  G_KEY_FILE_ERROR_PARSE,
>  G_KEY_FILE_ERROR_NOT_FOUND,
>  G_KEY_FILE_ERROR_KEY_NOT_FOUND,
>  G_KEY_FILE_ERROR_GROUP_NOT_FOUND,
>  G_KEY_FILE_ERROR_INVALID_VALUE
>} GKeyFileError;
>
>
>
>GQuark g_key_file_error_quark (void);
>
>typedef struct _GKeyFile GKeyFile;
>
>typedef enum
>{
>  G_KEY_FILE_NONE = 0,
>  G_KEY_FILE_KEEP_COMMENTS = 1 << 0,
>  G_KEY_FILE_KEEP_TRANSLATIONS = 1 << 1
>} GKeyFileFlags;
>
>GKeyFile *g_key_file_new (void);
>void g_key_file_free (GKeyFile *key_file);
>void g_key_file_set_list_separator (GKeyFile *key_file,
>          gchar separator);
>gboolean g_key_file_load_from_file (GKeyFile *key_file,
>          const gchar *file,
>          GKeyFileFlags flags,
>          GError **error);
>gboolean g_key_file_load_from_data (GKeyFile *key_file,
>          const gchar *data,
>          gsize length,
>          GKeyFileFlags flags,
>          GError **error);
>gboolean g_key_file_load_from_dirs (GKeyFile *key_file,
>          const gchar *file,
>          const gchar **search_dirs,
>          gchar **full_path,
>          GKeyFileFlags flags,
>          GError **error);
>gboolean g_key_file_load_from_data_dirs (GKeyFile *key_file,
>          const gchar *file,
>          gchar **full_path,
>          GKeyFileFlags flags,
>          GError **error);
>gchar *g_key_file_to_data (GKeyFile *key_file,
>          gsize *length,
>          GError **error) __attribute__((__malloc__));
>gchar *g_key_file_get_start_group (GKeyFile *key_file) __attribute__((__malloc__));
>gchar **g_key_file_get_groups (GKeyFile *key_file,
>          gsize *length) __attribute__((__malloc__));
>gchar **g_key_file_get_keys (GKeyFile *key_file,
>          const gchar *group_name,
>          gsize *length,
>          GError **error) __attribute__((__malloc__));
>gboolean g_key_file_has_group (GKeyFile *key_file,
>          const gchar *group_name);
>gboolean g_key_file_has_key (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          GError **error);
>gchar *g_key_file_get_value (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          GError **error) __attribute__((__malloc__));
>void g_key_file_set_value (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          const gchar *value);
>gchar *g_key_file_get_string (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          GError **error) __attribute__((__malloc__));
>void g_key_file_set_string (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          const gchar *string);
>gchar *g_key_file_get_locale_string (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          const gchar *locale,
>          GError **error) __attribute__((__malloc__));
>void g_key_file_set_locale_string (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          const gchar *locale,
>          const gchar *string);
>gboolean g_key_file_get_boolean (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          GError **error);
>void g_key_file_set_boolean (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          gboolean value);
>gint g_key_file_get_integer (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          GError **error);
>void g_key_file_set_integer (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          gint value);
>gdouble g_key_file_get_double (GKeyFile *key_file,
>                                             const gchar *group_name,
>                                             const gchar *key,
>                                             GError **error);
>void g_key_file_set_double (GKeyFile *key_file,
>                                             const gchar *group_name,
>                                             const gchar *key,
>                                             gdouble value);
>gchar **g_key_file_get_string_list (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          gsize *length,
>          GError **error) __attribute__((__malloc__));
>void g_key_file_set_string_list (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          const gchar * const list[],
>          gsize length);
>gchar **g_key_file_get_locale_string_list (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          const gchar *locale,
>          gsize *length,
>          GError **error) __attribute__((__malloc__));
>void g_key_file_set_locale_string_list (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          const gchar *locale,
>          const gchar * const list[],
>          gsize length);
>gboolean *g_key_file_get_boolean_list (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          gsize *length,
>          GError **error) __attribute__((__malloc__));
>void g_key_file_set_boolean_list (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          gboolean list[],
>          gsize length);
>gint *g_key_file_get_integer_list (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          gsize *length,
>          GError **error) __attribute__((__malloc__));
>void g_key_file_set_double_list (GKeyFile *key_file,
>                                             const gchar *group_name,
>                                             const gchar *key,
>                                             gdouble list[],
>                                             gsize length);
>gdouble *g_key_file_get_double_list (GKeyFile *key_file,
>                                             const gchar *group_name,
>                                             const gchar *key,
>                                             gsize *length,
>                                             GError **error) __attribute__((__malloc__));
>void g_key_file_set_integer_list (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          gint list[],
>          gsize length);
>gboolean g_key_file_set_comment (GKeyFile *key_file,
>                                             const gchar *group_name,
>                                             const gchar *key,
>                                             const gchar *comment,
>                                             GError **error);
>gchar *g_key_file_get_comment (GKeyFile *key_file,
>                                             const gchar *group_name,
>                                             const gchar *key,
>                                             GError **error) __attribute__((__malloc__));
>
>gboolean g_key_file_remove_comment (GKeyFile *key_file,
>                                             const gchar *group_name,
>                                             const gchar *key,
>          GError **error);
>gboolean g_key_file_remove_key (GKeyFile *key_file,
>          const gchar *group_name,
>          const gchar *key,
>          GError **error);
>gboolean g_key_file_remove_group (GKeyFile *key_file,
>          const gchar *group_name,
>          GError **error);
># 244 "../glib/gkeyfile.h"
>
># 50 "../glib/glib.h" 2
>
>
>
># 1 "../glib/gmappedfile.h" 1
># 26 "../glib/gmappedfile.h"
>
>
>typedef struct _GMappedFile GMappedFile;
>
>GMappedFile *g_mapped_file_new (const gchar *filename,
>             gboolean writable,
>             GError **error) __attribute__((__malloc__));
>gsize g_mapped_file_get_length (GMappedFile *file);
>gchar *g_mapped_file_get_contents (GMappedFile *file);
>void g_mapped_file_free (GMappedFile *file);
>
>
># 54 "../glib/glib.h" 2
># 1 "../glib/gmarkup.h" 1
># 29 "../glib/gmarkup.h"
>
>
>typedef enum
>{
>  G_MARKUP_ERROR_BAD_UTF8,
>  G_MARKUP_ERROR_EMPTY,
>  G_MARKUP_ERROR_PARSE,
>
>
>
>  G_MARKUP_ERROR_UNKNOWN_ELEMENT,
>  G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
>  G_MARKUP_ERROR_INVALID_CONTENT,
>  G_MARKUP_ERROR_MISSING_ATTRIBUTE
>} GMarkupError;
>
>
>
>GQuark g_markup_error_quark (void);
>
>typedef enum
>{
>  G_MARKUP_DO_NOT_USE_THIS_UNSUPPORTED_FLAG = 1 << 0,
>  G_MARKUP_TREAT_CDATA_AS_TEXT = 1 << 1,
>  G_MARKUP_PREFIX_ERROR_POSITION = 1 << 2
>} GMarkupParseFlags;
>
>typedef struct _GMarkupParseContext GMarkupParseContext;
>typedef struct _GMarkupParser GMarkupParser;
>
>struct _GMarkupParser
>{
>
>  void (*start_element) (GMarkupParseContext *context,
>                          const gchar *element_name,
>                          const gchar **attribute_names,
>                          const gchar **attribute_values,
>                          gpointer user_data,
>                          GError **error);
>
>
>  void (*end_element) (GMarkupParseContext *context,
>                          const gchar *element_name,
>                          gpointer user_data,
>                          GError **error);
>
>
>
>  void (*text) (GMarkupParseContext *context,
>                          const gchar *text,
>                          gsize text_len,
>                          gpointer user_data,
>                          GError **error);
>
>
>
>
>
>
>  void (*passthrough) (GMarkupParseContext *context,
>                          const gchar *passthrough_text,
>                          gsize text_len,
>                          gpointer user_data,
>                          GError **error);
>
>
>
>
>  void (*error) (GMarkupParseContext *context,
>                          GError *error,
>                          gpointer user_data);
>};
>
>GMarkupParseContext *g_markup_parse_context_new (const GMarkupParser *parser,
>                                                   GMarkupParseFlags flags,
>                                                   gpointer user_data,
>                                                   GDestroyNotify user_data_dnotify);
>void g_markup_parse_context_free (GMarkupParseContext *context);
>gboolean g_markup_parse_context_parse (GMarkupParseContext *context,
>                                                   const gchar *text,
>                                                   gssize text_len,
>                                                   GError **error);
>
>gboolean g_markup_parse_context_end_parse (GMarkupParseContext *context,
>                                                       GError **error);
> gchar *g_markup_parse_context_get_element (GMarkupParseContext *context);
> GSList *g_markup_parse_context_get_element_stack (GMarkupParseContext *context);
>
>
>void g_markup_parse_context_get_position (GMarkupParseContext *context,
>                                                          gint *line_number,
>                                                          gint *char_number);
>
>
>gchar* g_markup_escape_text (const gchar *text,
>                             gssize length);
>
>gchar *g_markup_printf_escaped (const char *format,
>    ...) __attribute__((__format__ (__printf__, 1, 2)));
>gchar *g_markup_vprintf_escaped (const char *format,
>     va_list args);
>
>typedef enum
>{
>  G_MARKUP_COLLECT_INVALID,
>  G_MARKUP_COLLECT_STRING,
>  G_MARKUP_COLLECT_STRDUP,
>  G_MARKUP_COLLECT_BOOLEAN,
>  G_MARKUP_COLLECT_TRISTATE,
>
>  G_MARKUP_COLLECT_OPTIONAL = (1 << 16)
>} GMarkupCollectType;
>
>
>
>gboolean g_markup_collect_attributes (const gchar *element_name,
>                                        const gchar **attribute_names,
>                                        const gchar **attribute_values,
>                                        GError **error,
>                                        GMarkupCollectType first_type,
>                                        const gchar *first_attr,
>                                        ...);
>
>
># 55 "../glib/glib.h" 2
>
># 1 "../glib/gmessages.h" 1
># 37 "../glib/gmessages.h"
>       
># 38 "../glib/gmessages.h" 3
>
>
>
>
>
>
>gsize g_printf_string_upper_bound (const gchar* format,
>         va_list args);
># 54 "../glib/gmessages.h" 3
>typedef enum
>{
>
>  G_LOG_FLAG_RECURSION = 1 << 0,
>  G_LOG_FLAG_FATAL = 1 << 1,
>
>
>  G_LOG_LEVEL_ERROR = 1 << 2,
>  G_LOG_LEVEL_CRITICAL = 1 << 3,
>  G_LOG_LEVEL_WARNING = 1 << 4,
>  G_LOG_LEVEL_MESSAGE = 1 << 5,
>  G_LOG_LEVEL_INFO = 1 << 6,
>  G_LOG_LEVEL_DEBUG = 1 << 7,
>
>  G_LOG_LEVEL_MASK = ~(G_LOG_FLAG_RECURSION | G_LOG_FLAG_FATAL)
>} GLogLevelFlags;
>
>
>
>
>typedef void (*GLogFunc) (const gchar *log_domain,
>                                                 GLogLevelFlags log_level,
>                                                 const gchar *message,
>                                                 gpointer user_data);
>
>
>
>guint g_log_set_handler (const gchar *log_domain,
>                                         GLogLevelFlags log_levels,
>                                         GLogFunc log_func,
>                                         gpointer user_data);
>void g_log_remove_handler (const gchar *log_domain,
>                                         guint handler_id);
>void g_log_default_handler (const gchar *log_domain,
>                                         GLogLevelFlags log_level,
>                                         const gchar *message,
>                                         gpointer unused_data);
>GLogFunc g_log_set_default_handler (GLogFunc log_func,
>        gpointer user_data);
>void g_log (const gchar *log_domain,
>                                         GLogLevelFlags log_level,
>                                         const gchar *format,
>                                         ...) __attribute__((__format__ (__printf__, 3, 4)));
>void g_logv (const gchar *log_domain,
>                                         GLogLevelFlags log_level,
>                                         const gchar *format,
>                                         va_list args);
>GLogLevelFlags g_log_set_fatal_mask (const gchar *log_domain,
>                                         GLogLevelFlags fatal_mask);
>GLogLevelFlags g_log_set_always_fatal (GLogLevelFlags fatal_mask);
>
>
>__attribute__((visibility("hidden"))) void _g_log_fallback_handler (const gchar *log_domain,
>       GLogLevelFlags log_level,
>       const gchar *message,
>       gpointer unused_data);
>
>
>void g_return_if_fail_warning (const char *log_domain,
>          const char *pretty_function,
>          const char *expression);
>void g_warn_message (const char *domain,
>                               const char *file,
>                               int line,
>                               const char *func,
>                               const char *warnexpr);
># 223 "../glib/gmessages.h" 3
>typedef void (*GPrintFunc) (const gchar *string);
>void g_print (const gchar *format,
>                                         ...) __attribute__((__format__ (__printf__, 1, 2)));
>GPrintFunc g_set_print_handler (GPrintFunc func);
>void g_printerr (const gchar *format,
>                                         ...) __attribute__((__format__ (__printf__, 1, 2)));
>GPrintFunc g_set_printerr_handler (GPrintFunc func);
># 335 "../glib/gmessages.h" 3
>
># 57 "../glib/glib.h" 2
># 1 "../glib/gnode.h" 1
># 32 "../glib/gnode.h"
>
>
>typedef struct _GNode GNode;
>
>
>typedef enum
>{
>  G_TRAVERSE_LEAVES = 1 << 0,
>  G_TRAVERSE_NON_LEAVES = 1 << 1,
>  G_TRAVERSE_ALL = G_TRAVERSE_LEAVES | G_TRAVERSE_NON_LEAVES,
>  G_TRAVERSE_MASK = 0x03,
>  G_TRAVERSE_LEAFS = G_TRAVERSE_LEAVES,
>  G_TRAVERSE_NON_LEAFS = G_TRAVERSE_NON_LEAVES
>} GTraverseFlags;
>
>
>typedef enum
>{
>  G_IN_ORDER,
>  G_PRE_ORDER,
>  G_POST_ORDER,
>  G_LEVEL_ORDER
>} GTraverseType;
>
>typedef gboolean (*GNodeTraverseFunc) (GNode *node,
>       gpointer data);
>typedef void (*GNodeForeachFunc) (GNode *node,
>       gpointer data);
># 73 "../glib/gnode.h"
>typedef gpointer (*GCopyFunc) (gconstpointer src,
>                                                 gpointer data);
>
>
>
>struct _GNode
>{
>  gpointer data;
>  GNode *next;
>  GNode *prev;
>  GNode *parent;
>  GNode *children;
>};
># 111 "../glib/gnode.h"
>GNode* g_node_new (gpointer data);
>void g_node_destroy (GNode *root);
>void g_node_unlink (GNode *node);
>GNode* g_node_copy_deep (GNode *node,
>     GCopyFunc copy_func,
>     gpointer data);
>GNode* g_node_copy (GNode *node);
>GNode* g_node_insert (GNode *parent,
>     gint position,
>     GNode *node);
>GNode* g_node_insert_before (GNode *parent,
>     GNode *sibling,
>     GNode *node);
>GNode* g_node_insert_after (GNode *parent,
>     GNode *sibling,
>     GNode *node);
>GNode* g_node_prepend (GNode *parent,
>     GNode *node);
>guint g_node_n_nodes (GNode *root,
>     GTraverseFlags flags);
>GNode* g_node_get_root (GNode *node);
>gboolean g_node_is_ancestor (GNode *node,
>     GNode *descendant);
>guint g_node_depth (GNode *node);
>GNode* g_node_find (GNode *root,
>     GTraverseType order,
>     GTraverseFlags flags,
>     gpointer data);
># 209 "../glib/gnode.h"
>void g_node_traverse (GNode *root,
>     GTraverseType order,
>     GTraverseFlags flags,
>     gint max_depth,
>     GNodeTraverseFunc func,
>     gpointer data);
>
>
>
>
>
>
>guint g_node_max_height (GNode *root);
>
>void g_node_children_foreach (GNode *node,
>      GTraverseFlags flags,
>      GNodeForeachFunc func,
>      gpointer data);
>void g_node_reverse_children (GNode *node);
>guint g_node_n_children (GNode *node);
>GNode* g_node_nth_child (GNode *node,
>      guint n);
>GNode* g_node_last_child (GNode *node);
>GNode* g_node_find_child (GNode *node,
>      GTraverseFlags flags,
>      gpointer data);
>gint g_node_child_position (GNode *node,
>      GNode *child);
>gint g_node_child_index (GNode *node,
>      gpointer data);
>
>GNode* g_node_first_sibling (GNode *node);
>GNode* g_node_last_sibling (GNode *node);
># 281 "../glib/gnode.h"
>
># 58 "../glib/glib.h" 2
># 1 "../glib/goption.h" 1
># 27 "../glib/goption.h"
>
>
>typedef struct _GOptionContext GOptionContext;
>typedef struct _GOptionGroup GOptionGroup;
>typedef struct _GOptionEntry GOptionEntry;
>
>typedef enum
>{
>  G_OPTION_FLAG_HIDDEN = 1 << 0,
>  G_OPTION_FLAG_IN_MAIN = 1 << 1,
>  G_OPTION_FLAG_REVERSE = 1 << 2,
>  G_OPTION_FLAG_NO_ARG = 1 << 3,
>  G_OPTION_FLAG_FILENAME = 1 << 4,
>  G_OPTION_FLAG_OPTIONAL_ARG = 1 << 5,
>  G_OPTION_FLAG_NOALIAS = 1 << 6
>} GOptionFlags;
>
>typedef enum
>{
>  G_OPTION_ARG_NONE,
>  G_OPTION_ARG_STRING,
>  G_OPTION_ARG_INT,
>  G_OPTION_ARG_CALLBACK,
>  G_OPTION_ARG_FILENAME,
>  G_OPTION_ARG_STRING_ARRAY,
>  G_OPTION_ARG_FILENAME_ARRAY,
>  G_OPTION_ARG_DOUBLE,
>  G_OPTION_ARG_INT64
>} GOptionArg;
>
>typedef gboolean (*GOptionArgFunc) (const gchar *option_name,
>        const gchar *value,
>        gpointer data,
>        GError **error);
>
>typedef gboolean (*GOptionParseFunc) (GOptionContext *context,
>          GOptionGroup *group,
>          gpointer data,
>          GError **error);
>
>typedef void (*GOptionErrorFunc) (GOptionContext *context,
>      GOptionGroup *group,
>      gpointer data,
>      GError **error);
>
>
>
>typedef enum
>{
>  G_OPTION_ERROR_UNKNOWN_OPTION,
>  G_OPTION_ERROR_BAD_VALUE,
>  G_OPTION_ERROR_FAILED
>} GOptionError;
>
>GQuark g_option_error_quark (void);
>
>
>struct _GOptionEntry
>{
>  const gchar *long_name;
>  gchar short_name;
>  gint flags;
>
>  GOptionArg arg;
>  gpointer arg_data;
>
>  const gchar *description;
>  const gchar *arg_description;
>};
>
>
>
>GOptionContext *g_option_context_new (const gchar *parameter_string);
>void g_option_context_set_summary (GOptionContext *context,
>                                                   const gchar *summary);
> gchar *g_option_context_get_summary (GOptionContext *context);
>void g_option_context_set_description (GOptionContext *context,
>                                                   const gchar *description);
> gchar *g_option_context_get_description (GOptionContext *context);
>void g_option_context_free (GOptionContext *context);
>void g_option_context_set_help_enabled (GOptionContext *context,
>         gboolean help_enabled);
>gboolean g_option_context_get_help_enabled (GOptionContext *context);
>void g_option_context_set_ignore_unknown_options (GOptionContext *context,
>            gboolean ignore_unknown);
>gboolean g_option_context_get_ignore_unknown_options (GOptionContext *context);
>
>void g_option_context_add_main_entries (GOptionContext *context,
>         const GOptionEntry *entries,
>         const gchar *translation_domain);
>gboolean g_option_context_parse (GOptionContext *context,
>         gint *argc,
>         gchar ***argv,
>         GError **error);
>void g_option_context_set_translate_func (GOptionContext *context,
>           GTranslateFunc func,
>           gpointer data,
>           GDestroyNotify destroy_notify);
>void g_option_context_set_translation_domain (GOptionContext *context,
>        const gchar *domain);
>
>void g_option_context_add_group (GOptionContext *context,
>       GOptionGroup *group);
>void g_option_context_set_main_group (GOptionContext *context,
>            GOptionGroup *group);
>GOptionGroup *g_option_context_get_main_group (GOptionContext *context);
>gchar *g_option_context_get_help (GOptionContext *context,
>                                               gboolean main_help,
>                                               GOptionGroup *group);
>
>GOptionGroup *g_option_group_new (const gchar *name,
>           const gchar *description,
>           const gchar *help_description,
>           gpointer user_data,
>           GDestroyNotify destroy);
>void g_option_group_set_parse_hooks (GOptionGroup *group,
>           GOptionParseFunc pre_parse_func,
>           GOptionParseFunc post_parse_func);
>void g_option_group_set_error_hook (GOptionGroup *group,
>           GOptionErrorFunc error_func);
>void g_option_group_free (GOptionGroup *group);
>void g_option_group_add_entries (GOptionGroup *group,
>           const GOptionEntry *entries);
>void g_option_group_set_translate_func (GOptionGroup *group,
>           GTranslateFunc func,
>           gpointer data,
>           GDestroyNotify destroy_notify);
>void g_option_group_set_translation_domain (GOptionGroup *group,
>           const gchar *domain);
>
>
>
># 59 "../glib/glib.h" 2
># 1 "../glib/gpattern.h" 1
># 24 "../glib/gpattern.h"
>
>
>
>typedef struct _GPatternSpec GPatternSpec;
>
>GPatternSpec* g_pattern_spec_new (const gchar *pattern);
>void g_pattern_spec_free (GPatternSpec *pspec);
>gboolean g_pattern_spec_equal (GPatternSpec *pspec1,
>     GPatternSpec *pspec2);
>gboolean g_pattern_match (GPatternSpec *pspec,
>     guint string_length,
>     const gchar *string,
>     const gchar *string_reversed);
>gboolean g_pattern_match_string (GPatternSpec *pspec,
>     const gchar *string);
>gboolean g_pattern_match_simple (const gchar *pattern,
>     const gchar *string);
>
>
># 60 "../glib/glib.h" 2
># 1 "../glib/gprimes.h" 1
># 32 "../glib/gprimes.h"
>
># 43 "../glib/gprimes.h"
>guint g_spaced_primes_closest (guint num) __attribute__((__const__));
>
>
># 61 "../glib/glib.h" 2
># 1 "../glib/gqsort.h" 1
># 33 "../glib/gqsort.h"
>
>
>void g_qsort_with_data (gconstpointer pbase,
>   gint total_elems,
>   gsize size,
>   GCompareDataFunc compare_func,
>   gpointer user_data);
>
>
># 62 "../glib/glib.h" 2
>
># 1 "../glib/gqueue.h" 1
># 32 "../glib/gqueue.h"
>
>
>typedef struct _GQueue GQueue;
>
>struct _GQueue
>{
>  GList *head;
>  GList *tail;
>  guint length;
>};
>
>
>
>
>
>GQueue* g_queue_new (void);
>void g_queue_free (GQueue *queue);
>void g_queue_init (GQueue *queue);
>void g_queue_clear (GQueue *queue);
>gboolean g_queue_is_empty (GQueue *queue);
>guint g_queue_get_length (GQueue *queue);
>void g_queue_reverse (GQueue *queue);
>GQueue * g_queue_copy (GQueue *queue);
>void g_queue_foreach (GQueue *queue,
>     GFunc func,
>     gpointer user_data);
>GList * g_queue_find (GQueue *queue,
>     gconstpointer data);
>GList * g_queue_find_custom (GQueue *queue,
>     gconstpointer data,
>     GCompareFunc func);
>void g_queue_sort (GQueue *queue,
>     GCompareDataFunc compare_func,
>     gpointer user_data);
>
>void g_queue_push_head (GQueue *queue,
>     gpointer data);
>void g_queue_push_tail (GQueue *queue,
>     gpointer data);
>void g_queue_push_nth (GQueue *queue,
>     gpointer data,
>     gint n);
>gpointer g_queue_pop_head (GQueue *queue);
>gpointer g_queue_pop_tail (GQueue *queue);
>gpointer g_queue_pop_nth (GQueue *queue,
>     guint n);
>gpointer g_queue_peek_head (GQueue *queue);
>gpointer g_queue_peek_tail (GQueue *queue);
>gpointer g_queue_peek_nth (GQueue *queue,
>     guint n);
>gint g_queue_index (GQueue *queue,
>     gconstpointer data);
>void g_queue_remove (GQueue *queue,
>     gconstpointer data);
>void g_queue_remove_all (GQueue *queue,
>     gconstpointer data);
>void g_queue_insert_before (GQueue *queue,
>     GList *sibling,
>     gpointer data);
>void g_queue_insert_after (GQueue *queue,
>     GList *sibling,
>     gpointer data);
>void g_queue_insert_sorted (GQueue *queue,
>     gpointer data,
>     GCompareDataFunc func,
>     gpointer user_data);
>
>void g_queue_push_head_link (GQueue *queue,
>     GList *link_);
>void g_queue_push_tail_link (GQueue *queue,
>     GList *link_);
>void g_queue_push_nth_link (GQueue *queue,
>     gint n,
>     GList *link_);
>GList* g_queue_pop_head_link (GQueue *queue);
>GList* g_queue_pop_tail_link (GQueue *queue);
>GList* g_queue_pop_nth_link (GQueue *queue,
>     guint n);
>GList* g_queue_peek_head_link (GQueue *queue);
>GList* g_queue_peek_tail_link (GQueue *queue);
>GList* g_queue_peek_nth_link (GQueue *queue,
>     guint n);
>gint g_queue_link_index (GQueue *queue,
>     GList *link_);
>void g_queue_unlink (GQueue *queue,
>     GList *link_);
>void g_queue_delete_link (GQueue *queue,
>     GList *link_);
>
>
># 64 "../glib/glib.h" 2
># 1 "../glib/grand.h" 1
># 32 "../glib/grand.h"
>
>
>typedef struct _GRand GRand;
># 45 "../glib/grand.h"
>GRand* g_rand_new_with_seed (guint32 seed);
>GRand* g_rand_new_with_seed_array (const guint32 *seed,
>        guint seed_length);
>GRand* g_rand_new (void);
>void g_rand_free (GRand *rand_);
>GRand* g_rand_copy (GRand *rand_);
>void g_rand_set_seed (GRand *rand_,
>          guint32 seed);
>void g_rand_set_seed_array (GRand *rand_,
>          const guint32 *seed,
>          guint seed_length);
>
>
>
>guint32 g_rand_int (GRand *rand_);
>gint32 g_rand_int_range (GRand *rand_,
>          gint32 begin,
>          gint32 end);
>gdouble g_rand_double (GRand *rand_);
>gdouble g_rand_double_range (GRand *rand_,
>          gdouble begin,
>          gdouble end);
>void g_random_set_seed (guint32 seed);
>
>
>
>guint32 g_random_int (void);
>gint32 g_random_int_range (gint32 begin,
>          gint32 end);
>gdouble g_random_double (void);
>gdouble g_random_double_range (gdouble begin,
>          gdouble end);
>
>
>
># 65 "../glib/glib.h" 2
># 1 "../glib/grel.h" 1
># 32 "../glib/grel.h"
>
>
>typedef struct _GRelation GRelation;
>typedef struct _GTuples GTuples;
>
>struct _GTuples
>{
>  guint len;
>};
># 65 "../glib/grel.h"
>GRelation* g_relation_new (gint fields);
>void g_relation_destroy (GRelation *relation);
>void g_relation_index (GRelation *relation,
>                               gint field,
>                               GHashFunc hash_func,
>                               GEqualFunc key_equal_func);
>void g_relation_insert (GRelation *relation,
>                               ...);
>gint g_relation_delete (GRelation *relation,
>                               gconstpointer key,
>                               gint field);
>GTuples* g_relation_select (GRelation *relation,
>                               gconstpointer key,
>                               gint field);
>gint g_relation_count (GRelation *relation,
>                               gconstpointer key,
>                               gint field);
>gboolean g_relation_exists (GRelation *relation,
>                               ...);
>void g_relation_print (GRelation *relation);
>
>void g_tuples_destroy (GTuples *tuples);
>gpointer g_tuples_index (GTuples *tuples,
>                               gint index_,
>                               gint field);
>
>
># 66 "../glib/glib.h" 2
># 1 "../glib/gregex.h" 1
># 28 "../glib/gregex.h"
>
>
>typedef enum
>{
>  G_REGEX_ERROR_COMPILE,
>  G_REGEX_ERROR_OPTIMIZE,
>  G_REGEX_ERROR_REPLACE,
>  G_REGEX_ERROR_MATCH,
>  G_REGEX_ERROR_INTERNAL,
>
>
>  G_REGEX_ERROR_STRAY_BACKSLASH = 101,
>  G_REGEX_ERROR_MISSING_CONTROL_CHAR = 102,
>  G_REGEX_ERROR_UNRECOGNIZED_ESCAPE = 103,
>  G_REGEX_ERROR_QUANTIFIERS_OUT_OF_ORDER = 104,
>  G_REGEX_ERROR_QUANTIFIER_TOO_BIG = 105,
>  G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS = 106,
>  G_REGEX_ERROR_INVALID_ESCAPE_IN_CHARACTER_CLASS = 107,
>  G_REGEX_ERROR_RANGE_OUT_OF_ORDER = 108,
>  G_REGEX_ERROR_NOTHING_TO_REPEAT = 109,
>  G_REGEX_ERROR_UNRECOGNIZED_CHARACTER = 112,
>  G_REGEX_ERROR_POSIX_NAMED_CLASS_OUTSIDE_CLASS = 113,
>  G_REGEX_ERROR_UNMATCHED_PARENTHESIS = 114,
>  G_REGEX_ERROR_INEXISTENT_SUBPATTERN_REFERENCE = 115,
>  G_REGEX_ERROR_UNTERMINATED_COMMENT = 118,
>  G_REGEX_ERROR_EXPRESSION_TOO_LARGE = 120,
>  G_REGEX_ERROR_MEMORY_ERROR = 121,
>  G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND = 125,
>  G_REGEX_ERROR_MALFORMED_CONDITION = 126,
>  G_REGEX_ERROR_TOO_MANY_CONDITIONAL_BRANCHES = 127,
>  G_REGEX_ERROR_ASSERTION_EXPECTED = 128,
>  G_REGEX_ERROR_UNKNOWN_POSIX_CLASS_NAME = 130,
>  G_REGEX_ERROR_POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED = 131,
>  G_REGEX_ERROR_HEX_CODE_TOO_LARGE = 134,
>  G_REGEX_ERROR_INVALID_CONDITION = 135,
>  G_REGEX_ERROR_SINGLE_BYTE_MATCH_IN_LOOKBEHIND = 136,
>  G_REGEX_ERROR_INFINITE_LOOP = 140,
>  G_REGEX_ERROR_MISSING_SUBPATTERN_NAME_TERMINATOR = 142,
>  G_REGEX_ERROR_DUPLICATE_SUBPATTERN_NAME = 143,
>  G_REGEX_ERROR_MALFORMED_PROPERTY = 146,
>  G_REGEX_ERROR_UNKNOWN_PROPERTY = 147,
>  G_REGEX_ERROR_SUBPATTERN_NAME_TOO_LONG = 148,
>  G_REGEX_ERROR_TOO_MANY_SUBPATTERNS = 149,
>  G_REGEX_ERROR_INVALID_OCTAL_VALUE = 151,
>  G_REGEX_ERROR_TOO_MANY_BRANCHES_IN_DEFINE = 154,
>  G_REGEX_ERROR_DEFINE_REPETION = 155,
>  G_REGEX_ERROR_INCONSISTENT_NEWLINE_OPTIONS = 156,
>  G_REGEX_ERROR_MISSING_BACK_REFERENCE = 157
>} GRegexError;
>
>
>
>GQuark g_regex_error_quark (void);
>
>
>
>typedef enum
>{
>  G_REGEX_CASELESS = 1 << 0,
>  G_REGEX_MULTILINE = 1 << 1,
>  G_REGEX_DOTALL = 1 << 2,
>  G_REGEX_EXTENDED = 1 << 3,
>  G_REGEX_ANCHORED = 1 << 4,
>  G_REGEX_DOLLAR_ENDONLY = 1 << 5,
>  G_REGEX_UNGREEDY = 1 << 9,
>  G_REGEX_RAW = 1 << 11,
>  G_REGEX_NO_AUTO_CAPTURE = 1 << 12,
>  G_REGEX_OPTIMIZE = 1 << 13,
>  G_REGEX_DUPNAMES = 1 << 19,
>  G_REGEX_NEWLINE_CR = 1 << 20,
>  G_REGEX_NEWLINE_LF = 1 << 21,
>  G_REGEX_NEWLINE_CRLF = G_REGEX_NEWLINE_CR | G_REGEX_NEWLINE_LF
>} GRegexCompileFlags;
>
>
>
>typedef enum
>{
>  G_REGEX_MATCH_ANCHORED = 1 << 4,
>  G_REGEX_MATCH_NOTBOL = 1 << 7,
>  G_REGEX_MATCH_NOTEOL = 1 << 8,
>  G_REGEX_MATCH_NOTEMPTY = 1 << 10,
>  G_REGEX_MATCH_PARTIAL = 1 << 15,
>  G_REGEX_MATCH_NEWLINE_CR = 1 << 20,
>  G_REGEX_MATCH_NEWLINE_LF = 1 << 21,
>  G_REGEX_MATCH_NEWLINE_CRLF = G_REGEX_MATCH_NEWLINE_CR | G_REGEX_MATCH_NEWLINE_LF,
>  G_REGEX_MATCH_NEWLINE_ANY = 1 << 22
>} GRegexMatchFlags;
>
>typedef struct _GRegex GRegex;
>typedef struct _GMatchInfo GMatchInfo;
>
>typedef gboolean (*GRegexEvalCallback) (const GMatchInfo *match_info,
>       GString *result,
>       gpointer user_data);
>
>
>GRegex *g_regex_new (const gchar *pattern,
>       GRegexCompileFlags compile_options,
>       GRegexMatchFlags match_options,
>       GError **error);
>GRegex *g_regex_ref (GRegex *regex);
>void g_regex_unref (GRegex *regex);
>const gchar *g_regex_get_pattern (const GRegex *regex);
>gint g_regex_get_max_backref (const GRegex *regex);
>gint g_regex_get_capture_count (const GRegex *regex);
>gint g_regex_get_string_number (const GRegex *regex,
>       const gchar *name);
>gchar *g_regex_escape_string (const gchar *string,
>       gint length);
>
>
>gboolean g_regex_match_simple (const gchar *pattern,
>       const gchar *string,
>       GRegexCompileFlags compile_options,
>       GRegexMatchFlags match_options);
>gboolean g_regex_match (const GRegex *regex,
>       const gchar *string,
>       GRegexMatchFlags match_options,
>       GMatchInfo **match_info);
>gboolean g_regex_match_full (const GRegex *regex,
>       const gchar *string,
>       gssize string_len,
>       gint start_position,
>       GRegexMatchFlags match_options,
>       GMatchInfo **match_info,
>       GError **error);
>gboolean g_regex_match_all (const GRegex *regex,
>       const gchar *string,
>       GRegexMatchFlags match_options,
>       GMatchInfo **match_info);
>gboolean g_regex_match_all_full (const GRegex *regex,
>       const gchar *string,
>       gssize string_len,
>       gint start_position,
>       GRegexMatchFlags match_options,
>       GMatchInfo **match_info,
>       GError **error);
>
>
>gchar **g_regex_split_simple (const gchar *pattern,
>       const gchar *string,
>       GRegexCompileFlags compile_options,
>       GRegexMatchFlags match_options);
>gchar **g_regex_split (const GRegex *regex,
>       const gchar *string,
>       GRegexMatchFlags match_options);
>gchar **g_regex_split_full (const GRegex *regex,
>       const gchar *string,
>       gssize string_len,
>       gint start_position,
>       GRegexMatchFlags match_options,
>       gint max_tokens,
>       GError **error);
>
>
>gchar *g_regex_replace (const GRegex *regex,
>       const gchar *string,
>       gssize string_len,
>       gint start_position,
>       const gchar *replacement,
>       GRegexMatchFlags match_options,
>       GError **error);
>gchar *g_regex_replace_literal (const GRegex *regex,
>       const gchar *string,
>       gssize string_len,
>       gint start_position,
>       const gchar *replacement,
>       GRegexMatchFlags match_options,
>       GError **error);
>gchar *g_regex_replace_eval (const GRegex *regex,
>       const gchar *string,
>       gssize string_len,
>       gint start_position,
>       GRegexMatchFlags match_options,
>       GRegexEvalCallback eval,
>       gpointer user_data,
>       GError **error);
>gboolean g_regex_check_replacement (const gchar *replacement,
>       gboolean *has_references,
>       GError **error);
>
>
>GRegex *g_match_info_get_regex (const GMatchInfo *match_info);
>const gchar *g_match_info_get_string (const GMatchInfo *match_info);
>
>void g_match_info_free (GMatchInfo *match_info);
>gboolean g_match_info_next (GMatchInfo *match_info,
>       GError **error);
>gboolean g_match_info_matches (const GMatchInfo *match_info);
>gint g_match_info_get_match_count (const GMatchInfo *match_info);
>gboolean g_match_info_is_partial_match (const GMatchInfo *match_info);
>gchar *g_match_info_expand_references(const GMatchInfo *match_info,
>       const gchar *string_to_expand,
>       GError **error);
>gchar *g_match_info_fetch (const GMatchInfo *match_info,
>       gint match_num);
>gboolean g_match_info_fetch_pos (const GMatchInfo *match_info,
>       gint match_num,
>       gint *start_pos,
>       gint *end_pos);
>gchar *g_match_info_fetch_named (const GMatchInfo *match_info,
>       const gchar *name);
>gboolean g_match_info_fetch_named_pos (const GMatchInfo *match_info,
>       const gchar *name,
>       gint *start_pos,
>       gint *end_pos);
>gchar **g_match_info_fetch_all (const GMatchInfo *match_info);
>
>
># 67 "../glib/glib.h" 2
># 1 "../glib/gscanner.h" 1
># 33 "../glib/gscanner.h"
>
>
>typedef struct _GScanner GScanner;
>typedef struct _GScannerConfig GScannerConfig;
>typedef union _GTokenValue GTokenValue;
>
>typedef void (*GScannerMsgFunc) (GScanner *scanner,
>       gchar *message,
>       gboolean error);
># 60 "../glib/gscanner.h"
>typedef enum
>{
>  G_ERR_UNKNOWN,
>  G_ERR_UNEXP_EOF,
>  G_ERR_UNEXP_EOF_IN_STRING,
>  G_ERR_UNEXP_EOF_IN_COMMENT,
>  G_ERR_NON_DIGIT_IN_CONST,
>  G_ERR_DIGIT_RADIX,
>  G_ERR_FLOAT_RADIX,
>  G_ERR_FLOAT_MALFORMED
>} GErrorType;
>
>
>typedef enum
>{
>  G_TOKEN_EOF = 0,
>
>  G_TOKEN_LEFT_PAREN = '(',
>  G_TOKEN_RIGHT_PAREN = ')',
>  G_TOKEN_LEFT_CURLY = '{',
>  G_TOKEN_RIGHT_CURLY = '}',
>  G_TOKEN_LEFT_BRACE = '[',
>  G_TOKEN_RIGHT_BRACE = ']',
>  G_TOKEN_EQUAL_SIGN = '=',
>  G_TOKEN_COMMA = ',',
>
>  G_TOKEN_NONE = 256,
>
>  G_TOKEN_ERROR,
>
>  G_TOKEN_CHAR,
>  G_TOKEN_BINARY,
>  G_TOKEN_OCTAL,
>  G_TOKEN_INT,
>  G_TOKEN_HEX,
>  G_TOKEN_FLOAT,
>  G_TOKEN_STRING,
>
>  G_TOKEN_SYMBOL,
>  G_TOKEN_IDENTIFIER,
>  G_TOKEN_IDENTIFIER_NULL,
>
>  G_TOKEN_COMMENT_SINGLE,
>  G_TOKEN_COMMENT_MULTI,
>  G_TOKEN_LAST
>} GTokenType;
>
>union _GTokenValue
>{
>  gpointer v_symbol;
>  gchar *v_identifier;
>  gulong v_binary;
>  gulong v_octal;
>  gulong v_int;
>  guint64 v_int64;
>  gdouble v_float;
>  gulong v_hex;
>  gchar *v_string;
>  gchar *v_comment;
>  guchar v_char;
>  guint v_error;
>};
>
>struct _GScannerConfig
>{
>
>
>  gchar *cset_skip_characters;
>  gchar *cset_identifier_first;
>  gchar *cset_identifier_nth;
>  gchar *cpair_comment_single;
>
>
>
>  guint case_sensitive : 1;
>
>
>
>
>  guint skip_comment_multi : 1;
>  guint skip_comment_single : 1;
>  guint scan_comment_multi : 1;
>  guint scan_identifier : 1;
>  guint scan_identifier_1char : 1;
>  guint scan_identifier_NULL : 1;
>  guint scan_symbols : 1;
>  guint scan_binary : 1;
>  guint scan_octal : 1;
>  guint scan_float : 1;
>  guint scan_hex : 1;
>  guint scan_hex_dollar : 1;
>  guint scan_string_sq : 1;
>  guint scan_string_dq : 1;
>  guint numbers_2_int : 1;
>  guint int_2_float : 1;
>  guint identifier_2_string : 1;
>  guint char_2_token : 1;
>  guint symbol_2_token : 1;
>  guint scope_0_fallback : 1;
>  guint store_int64 : 1;
>  guint padding_dummy;
>};
>
>struct _GScanner
>{
>
>  gpointer user_data;
>  guint max_parse_errors;
>
>
>  guint parse_errors;
>
>
>  const gchar *input_name;
>
>
>  GData *qdata;
>
>
>  GScannerConfig *config;
>
>
>  GTokenType token;
>  GTokenValue value;
>  guint line;
>  guint position;
>
>
>  GTokenType next_token;
>  GTokenValue next_value;
>  guint next_line;
>  guint next_position;
>
>
>  GHashTable *symbol_table;
>  gint input_fd;
>  const gchar *text;
>  const gchar *text_end;
>  gchar *buffer;
>  guint scope_id;
>
>
>  GScannerMsgFunc msg_handler;
>};
>
>GScanner* g_scanner_new (const GScannerConfig *config_templ);
>void g_scanner_destroy (GScanner *scanner);
>void g_scanner_input_file (GScanner *scanner,
>       gint input_fd);
>void g_scanner_sync_file_offset (GScanner *scanner);
>void g_scanner_input_text (GScanner *scanner,
>       const gchar *text,
>       guint text_len);
>GTokenType g_scanner_get_next_token (GScanner *scanner);
>GTokenType g_scanner_peek_next_token (GScanner *scanner);
>GTokenType g_scanner_cur_token (GScanner *scanner);
>GTokenValue g_scanner_cur_value (GScanner *scanner);
>guint g_scanner_cur_line (GScanner *scanner);
>guint g_scanner_cur_position (GScanner *scanner);
>gboolean g_scanner_eof (GScanner *scanner);
>guint g_scanner_set_scope (GScanner *scanner,
>       guint scope_id);
>void g_scanner_scope_add_symbol (GScanner *scanner,
>       guint scope_id,
>       const gchar *symbol,
>       gpointer value);
>void g_scanner_scope_remove_symbol (GScanner *scanner,
>       guint scope_id,
>       const gchar *symbol);
>gpointer g_scanner_scope_lookup_symbol (GScanner *scanner,
>       guint scope_id,
>       const gchar *symbol);
>void g_scanner_scope_foreach_symbol (GScanner *scanner,
>       guint scope_id,
>       GHFunc func,
>       gpointer user_data);
>gpointer g_scanner_lookup_symbol (GScanner *scanner,
>       const gchar *symbol);
>void g_scanner_unexp_token (GScanner *scanner,
>       GTokenType expected_token,
>       const gchar *identifier_spec,
>       const gchar *symbol_spec,
>       const gchar *symbol_name,
>       const gchar *message,
>       gint is_error);
>void g_scanner_error (GScanner *scanner,
>       const gchar *format,
>       ...) __attribute__((__format__ (__printf__, 2, 3)));
>void g_scanner_warn (GScanner *scanner,
>       const gchar *format,
>       ...) __attribute__((__format__ (__printf__, 2, 3)));
># 272 "../glib/gscanner.h"
>
># 68 "../glib/glib.h" 2
># 1 "../glib/gsequence.h" 1
># 26 "../glib/gsequence.h"
>typedef struct _GSequence GSequence;
>typedef struct _GSequenceNode GSequenceIter;
>
>typedef gint (* GSequenceIterCompareFunc) (GSequenceIter *a,
>                                           GSequenceIter *b,
>                                           gpointer data);
>
>
>
>GSequence * g_sequence_new (GDestroyNotify data_destroy);
>void g_sequence_free (GSequence *seq);
>gint g_sequence_get_length (GSequence *seq);
>void g_sequence_foreach (GSequence *seq,
>                                              GFunc func,
>                                              gpointer user_data);
>void g_sequence_foreach_range (GSequenceIter *begin,
>                                              GSequenceIter *end,
>                                              GFunc func,
>                                              gpointer user_data);
>void g_sequence_sort (GSequence *seq,
>                                              GCompareDataFunc cmp_func,
>                                              gpointer cmp_data);
>void g_sequence_sort_iter (GSequence *seq,
>                                              GSequenceIterCompareFunc cmp_func,
>                                              gpointer cmp_data);
>
>
>
>GSequenceIter *g_sequence_get_begin_iter (GSequence *seq);
>GSequenceIter *g_sequence_get_end_iter (GSequence *seq);
>GSequenceIter *g_sequence_get_iter_at_pos (GSequence *seq,
>                                              gint pos);
>GSequenceIter *g_sequence_append (GSequence *seq,
>                                              gpointer data);
>GSequenceIter *g_sequence_prepend (GSequence *seq,
>                                              gpointer data);
>GSequenceIter *g_sequence_insert_before (GSequenceIter *iter,
>                                              gpointer data);
>void g_sequence_move (GSequenceIter *src,
>                                              GSequenceIter *dest);
>void g_sequence_swap (GSequenceIter *a,
>                                              GSequenceIter *b);
>GSequenceIter *g_sequence_insert_sorted (GSequence *seq,
>                                              gpointer data,
>                                              GCompareDataFunc cmp_func,
>                                              gpointer cmp_data);
>GSequenceIter *g_sequence_insert_sorted_iter (GSequence *seq,
>                                              gpointer data,
>                                              GSequenceIterCompareFunc iter_cmp,
>                                              gpointer cmp_data);
>void g_sequence_sort_changed (GSequenceIter *iter,
>                                              GCompareDataFunc cmp_func,
>                                              gpointer cmp_data);
>void g_sequence_sort_changed_iter (GSequenceIter *iter,
>                                              GSequenceIterCompareFunc iter_cmp,
>                                              gpointer cmp_data);
>void g_sequence_remove (GSequenceIter *iter);
>void g_sequence_remove_range (GSequenceIter *begin,
>                                              GSequenceIter *end);
>void g_sequence_move_range (GSequenceIter *dest,
>                                              GSequenceIter *begin,
>                                              GSequenceIter *end);
>GSequenceIter *g_sequence_search (GSequence *seq,
>                                              gpointer data,
>                                              GCompareDataFunc cmp_func,
>                                              gpointer cmp_data);
>GSequenceIter *g_sequence_search_iter (GSequence *seq,
>                                              gpointer data,
>                                              GSequenceIterCompareFunc iter_cmp,
>                                              gpointer cmp_data);
>
>
>
>gpointer g_sequence_get (GSequenceIter *iter);
>void g_sequence_set (GSequenceIter *iter,
>                                              gpointer data);
>
>
>gboolean g_sequence_iter_is_begin (GSequenceIter *iter);
>gboolean g_sequence_iter_is_end (GSequenceIter *iter);
>GSequenceIter *g_sequence_iter_next (GSequenceIter *iter);
>GSequenceIter *g_sequence_iter_prev (GSequenceIter *iter);
>gint g_sequence_iter_get_position (GSequenceIter *iter);
>GSequenceIter *g_sequence_iter_move (GSequenceIter *iter,
>                                              gint delta);
>GSequence * g_sequence_iter_get_sequence (GSequenceIter *iter);
>
>
>
>gint g_sequence_iter_compare (GSequenceIter *a,
>                                              GSequenceIter *b);
>GSequenceIter *g_sequence_range_get_midpoint (GSequenceIter *begin,
>                                              GSequenceIter *end);
># 69 "../glib/glib.h" 2
># 1 "../glib/gshell.h" 1
># 26 "../glib/gshell.h"
>
>
>
>
>typedef enum
>{
>
>  G_SHELL_ERROR_BAD_QUOTING,
>
>  G_SHELL_ERROR_EMPTY_STRING,
>  G_SHELL_ERROR_FAILED
>} GShellError;
>
>GQuark g_shell_error_quark (void);
>
>gchar* g_shell_quote (const gchar *unquoted_string);
>gchar* g_shell_unquote (const gchar *quoted_string,
>                             GError **error);
>gboolean g_shell_parse_argv (const gchar *command_line,
>                             gint *argcp,
>                             gchar ***argvp,
>                             GError **error);
>
>
># 70 "../glib/glib.h" 2
>
># 1 "../glib/gspawn.h" 1
># 26 "../glib/gspawn.h"
>
>
>
>
>
>typedef enum
>{
>  G_SPAWN_ERROR_FORK,
>  G_SPAWN_ERROR_READ,
>  G_SPAWN_ERROR_CHDIR,
>  G_SPAWN_ERROR_ACCES,
>  G_SPAWN_ERROR_PERM,
>  G_SPAWN_ERROR_2BIG,
>  G_SPAWN_ERROR_NOEXEC,
>  G_SPAWN_ERROR_NAMETOOLONG,
>  G_SPAWN_ERROR_NOENT,
>  G_SPAWN_ERROR_NOMEM,
>  G_SPAWN_ERROR_NOTDIR,
>  G_SPAWN_ERROR_LOOP,
>  G_SPAWN_ERROR_TXTBUSY,
>  G_SPAWN_ERROR_IO,
>  G_SPAWN_ERROR_NFILE,
>  G_SPAWN_ERROR_MFILE,
>  G_SPAWN_ERROR_INVAL,
>  G_SPAWN_ERROR_ISDIR,
>  G_SPAWN_ERROR_LIBBAD,
>  G_SPAWN_ERROR_FAILED
>
>
>} GSpawnError;
>
>typedef void (* GSpawnChildSetupFunc) (gpointer user_data);
>
>typedef enum
>{
>  G_SPAWN_LEAVE_DESCRIPTORS_OPEN = 1 << 0,
>  G_SPAWN_DO_NOT_REAP_CHILD = 1 << 1,
>
>  G_SPAWN_SEARCH_PATH = 1 << 2,
>
>  G_SPAWN_STDOUT_TO_DEV_NULL = 1 << 3,
>  G_SPAWN_STDERR_TO_DEV_NULL = 1 << 4,
>  G_SPAWN_CHILD_INHERITS_STDIN = 1 << 5,
>  G_SPAWN_FILE_AND_ARGV_ZERO = 1 << 6
>} GSpawnFlags;
>
>GQuark g_spawn_error_quark (void);
># 82 "../glib/gspawn.h"
>gboolean g_spawn_async (const gchar *working_directory,
>                        gchar **argv,
>                        gchar **envp,
>                        GSpawnFlags flags,
>                        GSpawnChildSetupFunc child_setup,
>                        gpointer user_data,
>                        GPid *child_pid,
>                        GError **error);
>
>
>
>
>
>gboolean g_spawn_async_with_pipes (const gchar *working_directory,
>                                   gchar **argv,
>                                   gchar **envp,
>                                   GSpawnFlags flags,
>                                   GSpawnChildSetupFunc child_setup,
>                                   gpointer user_data,
>                                   GPid *child_pid,
>                                   gint *standard_input,
>                                   gint *standard_output,
>                                   gint *standard_error,
>                                   GError **error);
>
>
>
>
>
>
>gboolean g_spawn_sync (const gchar *working_directory,
>                               gchar **argv,
>                               gchar **envp,
>                               GSpawnFlags flags,
>                               GSpawnChildSetupFunc child_setup,
>                               gpointer user_data,
>                               gchar **standard_output,
>                               gchar **standard_error,
>                               gint *exit_status,
>                               GError **error);
>
>gboolean g_spawn_command_line_sync (const gchar *command_line,
>                                     gchar **standard_output,
>                                     gchar **standard_error,
>                                     gint *exit_status,
>                                     GError **error);
>gboolean g_spawn_command_line_async (const gchar *command_line,
>                                     GError **error);
>
>void g_spawn_close_pid (GPid pid);
>
>
>
># 72 "../glib/glib.h" 2
># 1 "../glib/gstrfuncs.h" 1
># 33 "../glib/gstrfuncs.h"
>
>
>
>typedef enum {
>  G_ASCII_ALNUM = 1 << 0,
>  G_ASCII_ALPHA = 1 << 1,
>  G_ASCII_CNTRL = 1 << 2,
>  G_ASCII_DIGIT = 1 << 3,
>  G_ASCII_GRAPH = 1 << 4,
>  G_ASCII_LOWER = 1 << 5,
>  G_ASCII_PRINT = 1 << 6,
>  G_ASCII_PUNCT = 1 << 7,
>  G_ASCII_SPACE = 1 << 8,
>  G_ASCII_UPPER = 1 << 9,
>  G_ASCII_XDIGIT = 1 << 10
>} GAsciiType;
>
>extern const guint16 * const g_ascii_table;
># 85 "../glib/gstrfuncs.h"
>gchar g_ascii_tolower (gchar c) __attribute__((__const__));
>gchar g_ascii_toupper (gchar c) __attribute__((__const__));
>
>gint g_ascii_digit_value (gchar c) __attribute__((__const__));
>gint g_ascii_xdigit_value (gchar c) __attribute__((__const__));
>
>
>
>
>
>gchar* g_strdelimit (gchar *string,
>     const gchar *delimiters,
>     gchar new_delimiter);
>gchar* g_strcanon (gchar *string,
>     const gchar *valid_chars,
>     gchar substitutor);
> gchar* g_strerror (gint errnum) __attribute__((__const__));
> gchar* g_strsignal (gint signum) __attribute__((__const__));
>gchar* g_strreverse (gchar *string);
>gsize g_strlcpy (gchar *dest,
>     const gchar *src,
>     gsize dest_size);
>gsize g_strlcat (gchar *dest,
>     const gchar *src,
>     gsize dest_size);
>gchar * g_strstr_len (const gchar *haystack,
>     gssize haystack_len,
>     const gchar *needle);
>gchar * g_strrstr (const gchar *haystack,
>     const gchar *needle);
>gchar * g_strrstr_len (const gchar *haystack,
>     gssize haystack_len,
>     const gchar *needle);
>
>gboolean g_str_has_suffix (const gchar *str,
>     const gchar *suffix);
>gboolean g_str_has_prefix (const gchar *str,
>     const gchar *prefix);
>
>
>
>gdouble g_strtod (const gchar *nptr,
>     gchar **endptr);
>gdouble g_ascii_strtod (const gchar *nptr,
>     gchar **endptr);
>guint64 g_ascii_strtoull (const gchar *nptr,
>     gchar **endptr,
>     guint base);
>gint64 g_ascii_strtoll (const gchar *nptr,
>     gchar **endptr,
>     guint base);
>
>
>
>
>gchar * g_ascii_dtostr (gchar *buffer,
>     gint buf_len,
>     gdouble d);
>gchar * g_ascii_formatd (gchar *buffer,
>     gint buf_len,
>     const gchar *format,
>     gdouble d);
>
>
>gchar* g_strchug (gchar *string);
>
>gchar* g_strchomp (gchar *string);
>
>
>
>gint g_ascii_strcasecmp (const gchar *s1,
>        const gchar *s2);
>gint g_ascii_strncasecmp (const gchar *s1,
>        const gchar *s2,
>        gsize n);
>gchar* g_ascii_strdown (const gchar *str,
>        gssize len) __attribute__((__malloc__));
>gchar* g_ascii_strup (const gchar *str,
>        gssize len) __attribute__((__malloc__));
># 185 "../glib/gstrfuncs.h"
>gchar* g_strdup (const gchar *str) __attribute__((__malloc__));
>gchar* g_strdup_printf (const gchar *format,
>     ...) __attribute__((__format__ (__printf__, 1, 2))) __attribute__((__malloc__));
>gchar* g_strdup_vprintf (const gchar *format,
>     va_list args) __attribute__((__malloc__));
>gchar* g_strndup (const gchar *str,
>     gsize n) __attribute__((__malloc__));
>gchar* g_strnfill (gsize length,
>     gchar fill_char) __attribute__((__malloc__));
>gchar* g_strconcat (const gchar *string1,
>     ...) __attribute__((__malloc__)) __attribute__((__sentinel__));
>gchar* g_strjoin (const gchar *separator,
>     ...) __attribute__((__malloc__)) __attribute__((__sentinel__));
>
>
>
>
>
>gchar* g_strcompress (const gchar *source) __attribute__((__malloc__));
># 213 "../glib/gstrfuncs.h"
>gchar* g_strescape (const gchar *source,
>     const gchar *exceptions) __attribute__((__malloc__));
>
>gpointer g_memdup (gconstpointer mem,
>     guint byte_size) __attribute__((__malloc__));
># 228 "../glib/gstrfuncs.h"
>gchar** g_strsplit (const gchar *string,
>     const gchar *delimiter,
>     gint max_tokens) __attribute__((__malloc__));
>gchar ** g_strsplit_set (const gchar *string,
>     const gchar *delimiters,
>     gint max_tokens) __attribute__((__malloc__));
>gchar* g_strjoinv (const gchar *separator,
>     gchar **str_array) __attribute__((__malloc__));
>void g_strfreev (gchar **str_array);
>gchar** g_strdupv (gchar **str_array) __attribute__((__malloc__));
>guint g_strv_length (gchar **str_array);
>
>gchar* g_stpcpy (gchar *dest,
>                                        const char *src);
>
> gchar *g_strip_context (const gchar *msgid,
>     const gchar *msgval);
>
> gchar *g_dpgettext (const gchar *domain,
>                                        const gchar *msgctxtid,
>                                        gsize msgidoffset);
>
>
># 73 "../glib/glib.h" 2
>
># 1 "../glib/gtestutils.h" 1
># 23 "../glib/gtestutils.h"
># 1 "../glib/glib.h" 1
># 24 "../glib/gtestutils.h" 2
>
>
>
>typedef struct GTestCase GTestCase;
>typedef struct GTestSuite GTestSuite;
># 61 "../glib/gtestutils.h"
>int g_strcmp0 (const char *str1,
>                                         const char *str2);
>
>
>void g_test_minimized_result (double minimized_quantity,
>                                         const char *format,
>                                         ...) __attribute__((__format__ (__printf__, 2, 3)));
>void g_test_maximized_result (double maximized_quantity,
>                                         const char *format,
>                                         ...) __attribute__((__format__ (__printf__, 2, 3)));
>
>
>void g_test_init (int *argc,
>                                         char ***argv,
>                                         ...);
># 84 "../glib/gtestutils.h"
>int g_test_run (void);
>
>void g_test_add_func (const char *testpath,
>                                         void (*test_func) (void));
>void g_test_add_data_func (const char *testpath,
>                                         gconstpointer test_data,
>                                         void (*test_func) (gconstpointer));
># 105 "../glib/gtestutils.h"
>void g_test_message (const char *format,
>                                         ...) __attribute__((__format__ (__printf__, 1, 2)));
>void g_test_bug_base (const char *uri_pattern);
>void g_test_bug (const char *bug_uri_snippet);
>
>void g_test_timer_start (void);
>double g_test_timer_elapsed (void);
>double g_test_timer_last (void);
>
>
>void g_test_queue_free (gpointer gfree_pointer);
>void g_test_queue_destroy (GDestroyNotify destroy_func,
>                                         gpointer destroy_data);
>
>
>
>typedef enum {
>  G_TEST_TRAP_SILENCE_STDOUT = 1 << 7,
>  G_TEST_TRAP_SILENCE_STDERR = 1 << 8,
>  G_TEST_TRAP_INHERIT_STDIN = 1 << 9
>} GTestTrapFlags;
>gboolean g_test_trap_fork (guint64 usec_timeout,
>                                         GTestTrapFlags test_trap_flags);
>gboolean g_test_trap_has_passed (void);
>gboolean g_test_trap_reached_timeout (void);
># 139 "../glib/gtestutils.h"
>gint32 g_test_rand_int (void);
>gint32 g_test_rand_int_range (gint32 begin,
>                                         gint32 end);
>double g_test_rand_double (void);
>double g_test_rand_double_range (double range_start,
>                                         double range_end);
>
>
>GTestCase* g_test_create_case (const char *test_name,
>                                         gsize data_size,
>                                         gconstpointer test_data,
>                                         void (*data_setup) (void),
>                                         void (*data_test) (void),
>                                         void (*data_teardown) (void));
>GTestSuite* g_test_create_suite (const char *suite_name);
>GTestSuite* g_test_get_root (void);
>void g_test_suite_add (GTestSuite *suite,
>                                         GTestCase *test_case);
>void g_test_suite_add_suite (GTestSuite *suite,
>                                         GTestSuite *nestedsuite);
>int g_test_run_suite (GTestSuite *suite);
>
>
>void g_test_trap_assertions (const char *domain,
>                                         const char *file,
>                                         int line,
>                                         const char *func,
>                                         guint64 assertion_flags,
>                                         const char *pattern);
>void g_assertion_message (const char *domain,
>                                         const char *file,
>                                         int line,
>                                         const char *func,
>                                         const char *message) __attribute__((__noreturn__));
>void g_assertion_message_expr (const char *domain,
>                                         const char *file,
>                                         int line,
>                                         const char *func,
>                                         const char *expr) __attribute__((__noreturn__));
>void g_assertion_message_cmpstr (const char *domain,
>                                         const char *file,
>                                         int line,
>                                         const char *func,
>                                         const char *expr,
>                                         const char *arg1,
>                                         const char *cmp,
>                                         const char *arg2) __attribute__((__noreturn__));
>void g_assertion_message_cmpnum (const char *domain,
>                                         const char *file,
>                                         int line,
>                                         const char *func,
>                                         const char *expr,
>                                         long double arg1,
>                                         const char *cmp,
>                                         long double arg2,
>                                         char numtype) __attribute__((__noreturn__));
>void g_test_add_vtable (const char *testpath,
>                                         gsize data_size,
>                                         gconstpointer test_data,
>                                         void (*data_setup) (void),
>                                         void (*data_test) (void),
>                                         void (*data_teardown) (void));
>typedef struct {
>  gboolean test_initialized;
>  gboolean test_quick;
>  gboolean test_perf;
>  gboolean test_verbose;
>  gboolean test_quiet;
>} GTestConfig;
>extern const GTestConfig * const g_test_config_vars;
>
>
>typedef enum {
>  G_TEST_LOG_NONE,
>  G_TEST_LOG_ERROR,
>  G_TEST_LOG_START_BINARY,
>  G_TEST_LOG_LIST_CASE,
>  G_TEST_LOG_SKIP_CASE,
>  G_TEST_LOG_START_CASE,
>  G_TEST_LOG_STOP_CASE,
>  G_TEST_LOG_MIN_RESULT,
>  G_TEST_LOG_MAX_RESULT,
>  G_TEST_LOG_MESSAGE
>} GTestLogType;
>
>typedef struct {
>  GTestLogType log_type;
>  guint n_strings;
>  gchar **strings;
>  guint n_nums;
>  long double *nums;
>} GTestLogMsg;
>typedef struct {
>
>  GString *data;
>  GSList *msgs;
>} GTestLogBuffer;
>
>const char* g_test_log_type_name (GTestLogType log_type);
>GTestLogBuffer* g_test_log_buffer_new (void);
>void g_test_log_buffer_free (GTestLogBuffer *tbuffer);
>void g_test_log_buffer_push (GTestLogBuffer *tbuffer,
>                                         guint n_bytes,
>                                         const guint8 *bytes);
>GTestLogMsg* g_test_log_buffer_pop (GTestLogBuffer *tbuffer);
>void g_test_log_msg_free (GTestLogMsg *tmsg);
>
>
># 75 "../glib/glib.h" 2
>
># 1 "../glib/gthreadpool.h" 1
># 32 "../glib/gthreadpool.h"
>
>
>typedef struct _GThreadPool GThreadPool;
>
>
>
>
>
>
>struct _GThreadPool
>{
>  GFunc func;
>  gpointer user_data;
>  gboolean exclusive;
>};
>
>
>
>
>
>
>GThreadPool* g_thread_pool_new (GFunc func,
>                                               gpointer user_data,
>                                               gint max_threads,
>                                               gboolean exclusive,
>                                               GError **error);
>
>
>
>
>
>void g_thread_pool_push (GThreadPool *pool,
>                                               gpointer data,
>                                               GError **error);
>
>
>
>
>void g_thread_pool_set_max_threads (GThreadPool *pool,
>                                               gint max_threads,
>                                               GError **error);
>gint g_thread_pool_get_max_threads (GThreadPool *pool);
>
>
>
>guint g_thread_pool_get_num_threads (GThreadPool *pool);
>
>
>guint g_thread_pool_unprocessed (GThreadPool *pool);
>
>
>
>
>
>void g_thread_pool_free (GThreadPool *pool,
>                                               gboolean immediate,
>                                               gboolean wait_);
>
>
>
>void g_thread_pool_set_max_unused_threads (gint max_threads);
>gint g_thread_pool_get_max_unused_threads (void);
>guint g_thread_pool_get_num_unused_threads (void);
>
>
>void g_thread_pool_stop_unused_threads (void);
>
>
>void g_thread_pool_set_sort_function (GThreadPool *pool,
>                                        GCompareDataFunc func,
>            gpointer user_data);
>
>
>void g_thread_pool_set_max_idle_time (guint interval);
>guint g_thread_pool_get_max_idle_time (void);
>
>
># 77 "../glib/glib.h" 2
># 1 "../glib/gtimer.h" 1
># 32 "../glib/gtimer.h"
>
>
>
>
>
>
>typedef struct _GTimer GTimer;
>
>
>
>GTimer* g_timer_new (void);
>void g_timer_destroy (GTimer *timer);
>void g_timer_start (GTimer *timer);
>void g_timer_stop (GTimer *timer);
>void g_timer_reset (GTimer *timer);
>void g_timer_continue (GTimer *timer);
>gdouble g_timer_elapsed (GTimer *timer,
>      gulong *microseconds);
>
>void g_usleep (gulong microseconds);
>
>void g_time_val_add (GTimeVal *time_,
>                                  glong microseconds);
>gboolean g_time_val_from_iso8601 (const gchar *iso_date,
>      GTimeVal *time_);
>gchar* g_time_val_to_iso8601 (GTimeVal *time_) __attribute__((__malloc__));
>
>
># 78 "../glib/glib.h" 2
># 1 "../glib/gtree.h" 1
># 32 "../glib/gtree.h"
>
>
>typedef struct _GTree GTree;
>
>typedef gboolean (*GTraverseFunc) (gpointer key,
>                                   gpointer value,
>                                   gpointer data);
>
>
>
>GTree* g_tree_new (GCompareFunc key_compare_func);
>GTree* g_tree_new_with_data (GCompareDataFunc key_compare_func,
>                                 gpointer key_compare_data);
>GTree* g_tree_new_full (GCompareDataFunc key_compare_func,
>                                 gpointer key_compare_data,
>                                 GDestroyNotify key_destroy_func,
>                                 GDestroyNotify value_destroy_func);
>void g_tree_destroy (GTree *tree);
>void g_tree_insert (GTree *tree,
>                                 gpointer key,
>                                 gpointer value);
>void g_tree_replace (GTree *tree,
>                                 gpointer key,
>                                 gpointer value);
>gboolean g_tree_remove (GTree *tree,
>                                 gconstpointer key);
>gboolean g_tree_steal (GTree *tree,
>                                 gconstpointer key);
>gpointer g_tree_lookup (GTree *tree,
>                                 gconstpointer key);
>gboolean g_tree_lookup_extended (GTree *tree,
>                                 gconstpointer lookup_key,
>                                 gpointer *orig_key,
>                                 gpointer *value);
>void g_tree_foreach (GTree *tree,
>                                 GTraverseFunc func,
>                                 gpointer user_data);
># 77 "../glib/gtree.h"
>gpointer g_tree_search (GTree *tree,
>                                 GCompareFunc search_func,
>                                 gconstpointer user_data);
>gint g_tree_height (GTree *tree);
>gint g_tree_nnodes (GTree *tree);
>
>
>
>
># 79 "../glib/glib.h" 2
>
>
># 1 "../glib/gurifuncs.h" 1
># 28 "../glib/gurifuncs.h"
>
># 65 "../glib/gurifuncs.h"
>char * g_uri_unescape_string (const char *escaped_string,
>          const char *illegal_characters);
>char * g_uri_unescape_segment (const char *escaped_string,
>          const char *escaped_string_end,
>          const char *illegal_characters);
>char * g_uri_parse_scheme (const char *uri);
>char * g_uri_escape_string (const char *unescaped,
>          const char *reserved_chars_allowed,
>          gboolean allow_utf8);
>
>
># 82 "../glib/glib.h" 2
># 27 "../gobject/gtype.h" 2
>
>
># 92 "../gobject/gtype.h"
>typedef gsize GType;
>
>
>
>typedef struct _GValue GValue;
>typedef union _GTypeCValue GTypeCValue;
>typedef struct _GTypePlugin GTypePlugin;
>typedef struct _GTypeClass GTypeClass;
>typedef struct _GTypeInterface GTypeInterface;
>typedef struct _GTypeInstance GTypeInstance;
>typedef struct _GTypeInfo GTypeInfo;
>typedef struct _GTypeFundamentalInfo GTypeFundamentalInfo;
>typedef struct _GInterfaceInfo GInterfaceInfo;
>typedef struct _GTypeValueTable GTypeValueTable;
>typedef struct _GTypeQuery GTypeQuery;
>
>
>
>
>struct _GTypeClass
>{
>
>  GType g_type;
>};
>struct _GTypeInstance
>{
>
>  GTypeClass *g_class;
>};
>struct _GTypeInterface
>{
>
>  GType g_type;
>  GType g_instance_type;
>};
>struct _GTypeQuery
>{
>  GType type;
>  const gchar *type_name;
>  guint class_size;
>  guint instance_size;
>};
># 157 "../gobject/gtype.h"
>typedef enum
>{
>  G_TYPE_DEBUG_NONE = 0,
>  G_TYPE_DEBUG_OBJECTS = 1 << 0,
>  G_TYPE_DEBUG_SIGNALS = 1 << 1,
>  G_TYPE_DEBUG_MASK = 0x03
>} GTypeDebugFlags;
>
>
>
>void g_type_init (void);
>void g_type_init_with_debug_flags (GTypeDebugFlags debug_flags);
> gchar* g_type_name (GType type);
>GQuark g_type_qname (GType type);
>GType g_type_from_name (const gchar *name);
>GType g_type_parent (GType type);
>guint g_type_depth (GType type);
>GType g_type_next_base (GType leaf_type,
>            GType root_type);
>gboolean g_type_is_a (GType type,
>            GType is_a_type);
>gpointer g_type_class_ref (GType type);
>gpointer g_type_class_peek (GType type);
>gpointer g_type_class_peek_static (GType type);
>void g_type_class_unref (gpointer g_class);
>gpointer g_type_class_peek_parent (gpointer g_class);
>gpointer g_type_interface_peek (gpointer instance_class,
>            GType iface_type);
>gpointer g_type_interface_peek_parent (gpointer g_iface);
>
>gpointer g_type_default_interface_ref (GType g_type);
>gpointer g_type_default_interface_peek (GType g_type);
>void g_type_default_interface_unref (gpointer g_iface);
>
>
>GType* g_type_children (GType type,
>            guint *n_children);
>GType* g_type_interfaces (GType type,
>            guint *n_interfaces);
>
>
>void g_type_set_qdata (GType type,
>            GQuark quark,
>            gpointer data);
>gpointer g_type_get_qdata (GType type,
>            GQuark quark);
>void g_type_query (GType type,
>            GTypeQuery *query);
>
>
>
>typedef void (*GBaseInitFunc) (gpointer g_class);
>typedef void (*GBaseFinalizeFunc) (gpointer g_class);
>typedef void (*GClassInitFunc) (gpointer g_class,
>           gpointer class_data);
>typedef void (*GClassFinalizeFunc) (gpointer g_class,
>           gpointer class_data);
>typedef void (*GInstanceInitFunc) (GTypeInstance *instance,
>           gpointer g_class);
>typedef void (*GInterfaceInitFunc) (gpointer g_iface,
>           gpointer iface_data);
>typedef void (*GInterfaceFinalizeFunc) (gpointer g_iface,
>           gpointer iface_data);
>typedef gboolean (*GTypeClassCacheFunc) (gpointer cache_data,
>           GTypeClass *g_class);
>typedef void (*GTypeInterfaceCheckFunc) (gpointer check_data,
>           gpointer g_iface);
>typedef enum
>{
>  G_TYPE_FLAG_CLASSED = (1 << 0),
>  G_TYPE_FLAG_INSTANTIATABLE = (1 << 1),
>  G_TYPE_FLAG_DERIVABLE = (1 << 2),
>  G_TYPE_FLAG_DEEP_DERIVABLE = (1 << 3)
>} GTypeFundamentalFlags;
>typedef enum
>{
>  G_TYPE_FLAG_ABSTRACT = (1 << 4),
>  G_TYPE_FLAG_VALUE_ABSTRACT = (1 << 5)
>} GTypeFlags;
>struct _GTypeInfo
>{
>
>  guint16 class_size;
>
>  GBaseInitFunc base_init;
>  GBaseFinalizeFunc base_finalize;
>
>
>  GClassInitFunc class_init;
>  GClassFinalizeFunc class_finalize;
>  gconstpointer class_data;
>
>
>  guint16 instance_size;
>  guint16 n_preallocs;
>  GInstanceInitFunc instance_init;
>
>
>  const GTypeValueTable *value_table;
>};
>struct _GTypeFundamentalInfo
>{
>  GTypeFundamentalFlags type_flags;
>};
>struct _GInterfaceInfo
>{
>  GInterfaceInitFunc interface_init;
>  GInterfaceFinalizeFunc interface_finalize;
>  gpointer interface_data;
>};
>struct _GTypeValueTable
>{
>  void (*value_init) (GValue *value);
>  void (*value_free) (GValue *value);
>  void (*value_copy) (const GValue *src_value,
>      GValue *dest_value);
>
>  gpointer (*value_peek_pointer) (const GValue *value);
>  gchar *collect_format;
>  gchar* (*collect_value) (GValue *value,
>      guint n_collect_values,
>      GTypeCValue *collect_values,
>      guint collect_flags);
>  gchar *lcopy_format;
>  gchar* (*lcopy_value) (const GValue *value,
>      guint n_collect_values,
>      GTypeCValue *collect_values,
>      guint collect_flags);
>};
>GType g_type_register_static (GType parent_type,
>      const gchar *type_name,
>      const GTypeInfo *info,
>      GTypeFlags flags);
>GType g_type_register_static_simple (GType parent_type,
>      const gchar *type_name,
>      guint class_size,
>      GClassInitFunc class_init,
>      guint instance_size,
>      GInstanceInitFunc instance_init,
>      GTypeFlags flags);
>
>GType g_type_register_dynamic (GType parent_type,
>      const gchar *type_name,
>      GTypePlugin *plugin,
>      GTypeFlags flags);
>GType g_type_register_fundamental (GType type_id,
>      const gchar *type_name,
>      const GTypeInfo *info,
>      const GTypeFundamentalInfo *finfo,
>      GTypeFlags flags);
>void g_type_add_interface_static (GType instance_type,
>      GType interface_type,
>      const GInterfaceInfo *info);
>void g_type_add_interface_dynamic (GType instance_type,
>      GType interface_type,
>      GTypePlugin *plugin);
>void g_type_interface_add_prerequisite (GType interface_type,
>      GType prerequisite_type);
>GType*g_type_interface_prerequisites (GType interface_type,
>      guint *n_prerequisites);
>void g_type_class_add_private (gpointer g_class,
>                                         gsize private_size);
>gpointer g_type_instance_get_private (GTypeInstance *instance,
>                                         GType private_type);
># 393 "../gobject/gtype.h"
>GTypePlugin* g_type_get_plugin (GType type);
>GTypePlugin* g_type_interface_get_plugin (GType instance_type,
>       GType interface_type);
>GType g_type_fundamental_next (void);
>GType g_type_fundamental (GType type_id);
>GTypeInstance* g_type_create_instance (GType type);
>void g_type_free_instance (GTypeInstance *instance);
>
>void g_type_add_class_cache_func (gpointer cache_data,
>       GTypeClassCacheFunc cache_func);
>void g_type_remove_class_cache_func (gpointer cache_data,
>       GTypeClassCacheFunc cache_func);
>void g_type_class_unref_uncached (gpointer g_class);
>
>void g_type_add_interface_check (gpointer check_data,
>       GTypeInterfaceCheckFunc check_func);
>void g_type_remove_interface_check (gpointer check_data,
>       GTypeInterfaceCheckFunc check_func);
>
>GTypeValueTable* g_type_value_table_peek (GType type);
>
>
>
>gboolean g_type_check_instance (GTypeInstance *instance) __attribute__((__pure__));
>GTypeInstance* g_type_check_instance_cast (GTypeInstance *instance,
>       GType iface_type);
>gboolean g_type_check_instance_is_a (GTypeInstance *instance,
>       GType iface_type) __attribute__((__pure__));
>GTypeClass* g_type_check_class_cast (GTypeClass *g_class,
>       GType is_a_type);
>gboolean g_type_check_class_is_a (GTypeClass *g_class,
>       GType is_a_type) __attribute__((__pure__));
>gboolean g_type_check_is_value_type (GType type) __attribute__((__const__));
>gboolean g_type_check_value (GValue *value) __attribute__((__pure__));
>gboolean g_type_check_value_holds (GValue *value,
>       GType type) __attribute__((__pure__));
>gboolean g_type_test_flags (GType type,
>       guint flags) __attribute__((__const__));
>
>
>
> gchar* g_type_name_from_instance (GTypeInstance *instance);
> gchar* g_type_name_from_class (GTypeClass *g_class);
>
>
>
>__attribute__((visibility("hidden"))) void g_value_c_init (void);
>__attribute__((visibility("hidden"))) void g_value_types_init (void);
>__attribute__((visibility("hidden"))) void g_enum_types_init (void);
>__attribute__((visibility("hidden"))) void g_param_type_init (void);
>__attribute__((visibility("hidden"))) void g_boxed_type_init (void);
>__attribute__((visibility("hidden"))) void g_object_type_init (void);
>__attribute__((visibility("hidden"))) void g_param_spec_types_init (void);
>__attribute__((visibility("hidden"))) void g_value_transforms_init (void);
>__attribute__((visibility("hidden"))) void g_signal_init (void);
># 495 "../gobject/gtype.h"
>extern GTypeDebugFlags _g_type_debug_flags;
>
>
># 28 "../gobject/gclosure.h" 2
>
>
># 40 "../gobject/gclosure.h"
>typedef struct _GClosure GClosure;
>typedef struct _GClosureNotifyData GClosureNotifyData;
>typedef void (*GCallback) (void);
>typedef void (*GClosureNotify) (gpointer data,
>      GClosure *closure);
>typedef void (*GClosureMarshal) (GClosure *closure,
>      GValue *return_value,
>      guint n_param_values,
>      const GValue *param_values,
>      gpointer invocation_hint,
>      gpointer marshal_data);
>typedef struct _GCClosure GCClosure;
>
>
>
>struct _GClosureNotifyData
>{
>  gpointer data;
>  GClosureNotify notify;
>};
>struct _GClosure
>{
>
>  volatile guint ref_count : 15;
>  volatile guint meta_marshal : 1;
>  volatile guint n_guards : 1;
>  volatile guint n_fnotifiers : 2;
>  volatile guint n_inotifiers : 8;
>  volatile guint in_inotify : 1;
>  volatile guint floating : 1;
>
>  volatile guint derivative_flag : 1;
>
>  volatile guint in_marshal : 1;
>  volatile guint is_invalid : 1;
>
>                  void (*marshal) (GClosure *closure,
>         GValue *return_value,
>         guint n_param_values,
>         const GValue *param_values,
>         gpointer invocation_hint,
>         gpointer marshal_data);
>                    gpointer data;
>
>                  GClosureNotifyData *notifiers;
># 96 "../gobject/gclosure.h"
>};
>
>
>struct _GCClosure
>{
>  GClosure closure;
>  gpointer callback;
>};
>
>
>
>GClosure* g_cclosure_new (GCallback callback_func,
>       gpointer user_data,
>       GClosureNotify destroy_data);
>GClosure* g_cclosure_new_swap (GCallback callback_func,
>       gpointer user_data,
>       GClosureNotify destroy_data);
>GClosure* g_signal_type_cclosure_new (GType itype,
>       guint struct_offset);
>
>
>
>GClosure* g_closure_ref (GClosure *closure);
>void g_closure_sink (GClosure *closure);
>void g_closure_unref (GClosure *closure);
>
>GClosure* g_closure_new_simple (guint sizeof_closure,
>       gpointer data);
>void g_closure_add_finalize_notifier (GClosure *closure,
>       gpointer notify_data,
>       GClosureNotify notify_func);
>void g_closure_remove_finalize_notifier (GClosure *closure,
>       gpointer notify_data,
>       GClosureNotify notify_func);
>void g_closure_add_invalidate_notifier (GClosure *closure,
>       gpointer notify_data,
>       GClosureNotify notify_func);
>void g_closure_remove_invalidate_notifier (GClosure *closure,
>       gpointer notify_data,
>       GClosureNotify notify_func);
>void g_closure_add_marshal_guards (GClosure *closure,
>       gpointer pre_marshal_data,
>       GClosureNotify pre_marshal_notify,
>       gpointer post_marshal_data,
>       GClosureNotify post_marshal_notify);
>void g_closure_set_marshal (GClosure *closure,
>       GClosureMarshal marshal);
>void g_closure_set_meta_marshal (GClosure *closure,
>       gpointer marshal_data,
>       GClosureMarshal meta_marshal);
>void g_closure_invalidate (GClosure *closure);
>void g_closure_invoke (GClosure *closure,
>       GValue *return_value,
>       guint n_param_values,
>       const GValue *param_values,
>       gpointer invocation_hint);
># 164 "../gobject/gclosure.h"
>
># 27 "gsignal.h" 2
># 1 "../gobject/gvalue.h" 1
># 28 "../gobject/gvalue.h"
># 1 "../gobject/gtype.h" 1
># 29 "../gobject/gvalue.h" 2
>
>
># 41 "../gobject/gvalue.h"
>typedef void (*GValueTransform) (const GValue *src_value,
>     GValue *dest_value);
>struct _GValue
>{
>
>  GType g_type;
>
>
>  union {
>    gint v_int;
>    guint v_uint;
>    glong v_long;
>    gulong v_ulong;
>    gint64 v_int64;
>    guint64 v_uint64;
>    gfloat v_float;
>    gdouble v_double;
>    gpointer v_pointer;
>  } data[2];
>};
>
>
>
>GValue* g_value_init (GValue *value,
>      GType g_type);
>void g_value_copy (const GValue *src_value,
>      GValue *dest_value);
>GValue* g_value_reset (GValue *value);
>void g_value_unset (GValue *value);
>void g_value_set_instance (GValue *value,
>      gpointer instance);
>
>
>
>gboolean g_value_fits_pointer (const GValue *value);
>gpointer g_value_peek_pointer (const GValue *value);
>
>
>
>gboolean g_value_type_compatible (GType src_type,
>      GType dest_type);
>gboolean g_value_type_transformable (GType src_type,
>      GType dest_type);
>gboolean g_value_transform (const GValue *src_value,
>      GValue *dest_value);
>void g_value_register_transform_func (GType src_type,
>      GType dest_type,
>      GValueTransform transform_func);
>
>
>
>
># 28 "gsignal.h" 2
># 1 "../gobject/gparam.h" 1
># 28 "../gobject/gparam.h"
># 1 "../gobject/gvalue.h" 1
># 29 "../gobject/gparam.h" 2
>
>
># 49 "../gobject/gparam.h"
>typedef enum
>{
>  G_PARAM_READABLE = 1 << 0,
>  G_PARAM_WRITABLE = 1 << 1,
>  G_PARAM_CONSTRUCT = 1 << 2,
>  G_PARAM_CONSTRUCT_ONLY = 1 << 3,
>  G_PARAM_LAX_VALIDATION = 1 << 4,
>  G_PARAM_STATIC_NAME = 1 << 5,
>
>
>
>  G_PARAM_STATIC_NICK = 1 << 6,
>  G_PARAM_STATIC_BLURB = 1 << 7
>} GParamFlags;
># 71 "../gobject/gparam.h"
>typedef struct _GParamSpec GParamSpec;
>typedef struct _GParamSpecClass GParamSpecClass;
>typedef struct _GParameter GParameter;
>typedef struct _GParamSpecPool GParamSpecPool;
>struct _GParamSpec
>{
>  GTypeInstance g_type_instance;
>
>  gchar *name;
>  GParamFlags flags;
>  GType value_type;
>  GType owner_type;
>
>
>  gchar *_nick;
>  gchar *_blurb;
>  GData *qdata;
>  guint ref_count;
>  guint param_id;
>};
>struct _GParamSpecClass
>{
>  GTypeClass g_type_class;
>
>  GType value_type;
>
>  void (*finalize) (GParamSpec *pspec);
>
>
>  void (*value_set_default) (GParamSpec *pspec,
>      GValue *value);
>  gboolean (*value_validate) (GParamSpec *pspec,
>      GValue *value);
>  gint (*values_cmp) (GParamSpec *pspec,
>      const GValue *value1,
>      const GValue *value2);
>
>  gpointer dummy[4];
>};
>struct _GParameter
>{
>  const gchar *name;
>  GValue value;
>};
>
>
>
>GParamSpec* g_param_spec_ref (GParamSpec *pspec);
>void g_param_spec_unref (GParamSpec *pspec);
>void g_param_spec_sink (GParamSpec *pspec);
>GParamSpec* g_param_spec_ref_sink (GParamSpec *pspec);
>gpointer g_param_spec_get_qdata (GParamSpec *pspec,
>       GQuark quark);
>void g_param_spec_set_qdata (GParamSpec *pspec,
>       GQuark quark,
>       gpointer data);
>void g_param_spec_set_qdata_full (GParamSpec *pspec,
>       GQuark quark,
>       gpointer data,
>       GDestroyNotify destroy);
>gpointer g_param_spec_steal_qdata (GParamSpec *pspec,
>       GQuark quark);
>GParamSpec* g_param_spec_get_redirect_target (GParamSpec *pspec);
>
>void g_param_value_set_default (GParamSpec *pspec,
>       GValue *value);
>gboolean g_param_value_defaults (GParamSpec *pspec,
>       GValue *value);
>gboolean g_param_value_validate (GParamSpec *pspec,
>       GValue *value);
>gboolean g_param_value_convert (GParamSpec *pspec,
>       const GValue *src_value,
>       GValue *dest_value,
>       gboolean strict_validation);
>gint g_param_values_cmp (GParamSpec *pspec,
>       const GValue *value1,
>       const GValue *value2);
> gchar* g_param_spec_get_name (GParamSpec *pspec);
> gchar* g_param_spec_get_nick (GParamSpec *pspec);
> gchar* g_param_spec_get_blurb (GParamSpec *pspec);
>void g_value_set_param (GValue *value,
>       GParamSpec *param);
>GParamSpec* g_value_get_param (const GValue *value);
>GParamSpec* g_value_dup_param (const GValue *value);
>
>
>void g_value_take_param (GValue *value,
>              GParamSpec *param);
>
>
>
>
>
>
>typedef struct _GParamSpecTypeInfo GParamSpecTypeInfo;
>struct _GParamSpecTypeInfo
>{
>
>  guint16 instance_size;
>  guint16 n_preallocs;
>  void (*instance_init) (GParamSpec *pspec);
>
>
>  GType value_type;
>  void (*finalize) (GParamSpec *pspec);
>  void (*value_set_default) (GParamSpec *pspec,
>      GValue *value);
>  gboolean (*value_validate) (GParamSpec *pspec,
>      GValue *value);
>  gint (*values_cmp) (GParamSpec *pspec,
>      const GValue *value1,
>      const GValue *value2);
>};
>GType g_param_type_register_static (const gchar *name,
>      const GParamSpecTypeInfo *pspec_info);
>
>
>GType _g_param_type_register_static_constant (const gchar *name,
>            const GParamSpecTypeInfo *pspec_info,
>            GType opt_type);
>
>
>
>gpointer g_param_spec_internal (GType param_type,
>       const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       GParamFlags flags);
>GParamSpecPool* g_param_spec_pool_new (gboolean type_prefixing);
>void g_param_spec_pool_insert (GParamSpecPool *pool,
>       GParamSpec *pspec,
>       GType owner_type);
>void g_param_spec_pool_remove (GParamSpecPool *pool,
>       GParamSpec *pspec);
>GParamSpec* g_param_spec_pool_lookup (GParamSpecPool *pool,
>       const gchar *param_name,
>       GType owner_type,
>       gboolean walk_ancestors);
>GList* g_param_spec_pool_list_owned (GParamSpecPool *pool,
>       GType owner_type);
>GParamSpec** g_param_spec_pool_list (GParamSpecPool *pool,
>       GType owner_type,
>       guint *n_pspecs_p);
># 233 "../gobject/gparam.h"
>
># 29 "gsignal.h" 2
># 1 "../gobject/gmarshal.h" 1
>
>
>
>
>
>
>extern void g_cclosure_marshal_VOID__VOID (GClosure *closure,
>                                           GValue *return_value,
>                                           guint n_param_values,
>                                           const GValue *param_values,
>                                           gpointer invocation_hint,
>                                           gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__BOOLEAN (GClosure *closure,
>                                              GValue *return_value,
>                                              guint n_param_values,
>                                              const GValue *param_values,
>                                              gpointer invocation_hint,
>                                              gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__CHAR (GClosure *closure,
>                                           GValue *return_value,
>                                           guint n_param_values,
>                                           const GValue *param_values,
>                                           gpointer invocation_hint,
>                                           gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__UCHAR (GClosure *closure,
>                                            GValue *return_value,
>                                            guint n_param_values,
>                                            const GValue *param_values,
>                                            gpointer invocation_hint,
>                                            gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__INT (GClosure *closure,
>                                          GValue *return_value,
>                                          guint n_param_values,
>                                          const GValue *param_values,
>                                          gpointer invocation_hint,
>                                          gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__UINT (GClosure *closure,
>                                           GValue *return_value,
>                                           guint n_param_values,
>                                           const GValue *param_values,
>                                           gpointer invocation_hint,
>                                           gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__LONG (GClosure *closure,
>                                           GValue *return_value,
>                                           guint n_param_values,
>                                           const GValue *param_values,
>                                           gpointer invocation_hint,
>                                           gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__ULONG (GClosure *closure,
>                                            GValue *return_value,
>                                            guint n_param_values,
>                                            const GValue *param_values,
>                                            gpointer invocation_hint,
>                                            gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__ENUM (GClosure *closure,
>                                           GValue *return_value,
>                                           guint n_param_values,
>                                           const GValue *param_values,
>                                           gpointer invocation_hint,
>                                           gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__FLAGS (GClosure *closure,
>                                            GValue *return_value,
>                                            guint n_param_values,
>                                            const GValue *param_values,
>                                            gpointer invocation_hint,
>                                            gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__FLOAT (GClosure *closure,
>                                            GValue *return_value,
>                                            guint n_param_values,
>                                            const GValue *param_values,
>                                            gpointer invocation_hint,
>                                            gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__DOUBLE (GClosure *closure,
>                                             GValue *return_value,
>                                             guint n_param_values,
>                                             const GValue *param_values,
>                                             gpointer invocation_hint,
>                                             gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__STRING (GClosure *closure,
>                                             GValue *return_value,
>                                             guint n_param_values,
>                                             const GValue *param_values,
>                                             gpointer invocation_hint,
>                                             gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__PARAM (GClosure *closure,
>                                            GValue *return_value,
>                                            guint n_param_values,
>                                            const GValue *param_values,
>                                            gpointer invocation_hint,
>                                            gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__BOXED (GClosure *closure,
>                                            GValue *return_value,
>                                            guint n_param_values,
>                                            const GValue *param_values,
>                                            gpointer invocation_hint,
>                                            gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__POINTER (GClosure *closure,
>                                              GValue *return_value,
>                                              guint n_param_values,
>                                              const GValue *param_values,
>                                              gpointer invocation_hint,
>                                              gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__OBJECT (GClosure *closure,
>                                             GValue *return_value,
>                                             guint n_param_values,
>                                             const GValue *param_values,
>                                             gpointer invocation_hint,
>                                             gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_VOID__UINT_POINTER (GClosure *closure,
>                                                   GValue *return_value,
>                                                   guint n_param_values,
>                                                   const GValue *param_values,
>                                                   gpointer invocation_hint,
>                                                   gpointer marshal_data);
>
>
>extern void g_cclosure_marshal_BOOLEAN__FLAGS (GClosure *closure,
>                                               GValue *return_value,
>                                               guint n_param_values,
>                                               const GValue *param_values,
>                                               gpointer invocation_hint,
>                                               gpointer marshal_data);
>
>
>
>extern void g_cclosure_marshal_STRING__OBJECT_POINTER (GClosure *closure,
>                                                       GValue *return_value,
>                                                       guint n_param_values,
>                                                       const GValue *param_values,
>                                                       gpointer invocation_hint,
>                                                       gpointer marshal_data);
>
>
># 30 "gsignal.h" 2
>
>
>
>
>typedef struct _GSignalQuery GSignalQuery;
>typedef struct _GSignalInvocationHint GSignalInvocationHint;
>typedef GClosureMarshal GSignalCMarshaller;
>typedef gboolean (*GSignalEmissionHook) (GSignalInvocationHint *ihint,
>      guint n_param_values,
>      const GValue *param_values,
>      gpointer data);
>typedef gboolean (*GSignalAccumulator) (GSignalInvocationHint *ihint,
>      GValue *return_accu,
>      const GValue *handler_return,
>      gpointer data);
>
>
>
>typedef enum
>{
>  G_SIGNAL_RUN_FIRST = 1 << 0,
>  G_SIGNAL_RUN_LAST = 1 << 1,
>  G_SIGNAL_RUN_CLEANUP = 1 << 2,
>  G_SIGNAL_NO_RECURSE = 1 << 3,
>  G_SIGNAL_DETAILED = 1 << 4,
>  G_SIGNAL_ACTION = 1 << 5,
>  G_SIGNAL_NO_HOOKS = 1 << 6
>} GSignalFlags;
>
>typedef enum
>{
>  G_CONNECT_AFTER = 1 << 0,
>  G_CONNECT_SWAPPED = 1 << 1
>} GConnectFlags;
>typedef enum
>{
>  G_SIGNAL_MATCH_ID = 1 << 0,
>  G_SIGNAL_MATCH_DETAIL = 1 << 1,
>  G_SIGNAL_MATCH_CLOSURE = 1 << 2,
>  G_SIGNAL_MATCH_FUNC = 1 << 3,
>  G_SIGNAL_MATCH_DATA = 1 << 4,
>  G_SIGNAL_MATCH_UNBLOCKED = 1 << 5
>} GSignalMatchType;
>
>
>
>
>
>struct _GSignalInvocationHint
>{
>  guint signal_id;
>  GQuark detail;
>  GSignalFlags run_type;
>};
>struct _GSignalQuery
>{
>  guint signal_id;
>  const gchar *signal_name;
>  GType itype;
>  GSignalFlags signal_flags;
>  GType return_type;
>  guint n_params;
>  const GType *param_types;
>};
>
>
>
>guint g_signal_newv (const gchar *signal_name,
>          GType itype,
>          GSignalFlags signal_flags,
>          GClosure *class_closure,
>          GSignalAccumulator accumulator,
>          gpointer accu_data,
>          GSignalCMarshaller c_marshaller,
>          GType return_type,
>          guint n_params,
>          GType *param_types);
>guint g_signal_new_valist (const gchar *signal_name,
>          GType itype,
>          GSignalFlags signal_flags,
>          GClosure *class_closure,
>          GSignalAccumulator accumulator,
>          gpointer accu_data,
>          GSignalCMarshaller c_marshaller,
>          GType return_type,
>          guint n_params,
>          va_list args);
>guint g_signal_new (const gchar *signal_name,
>          GType itype,
>          GSignalFlags signal_flags,
>          guint class_offset,
>          GSignalAccumulator accumulator,
>          gpointer accu_data,
>          GSignalCMarshaller c_marshaller,
>          GType return_type,
>          guint n_params,
>          ...);
>void g_signal_emitv (const GValue *instance_and_params,
>          guint signal_id,
>          GQuark detail,
>          GValue *return_value);
>void g_signal_emit_valist (gpointer instance,
>          guint signal_id,
>          GQuark detail,
>          va_list var_args);
>void g_signal_emit (gpointer instance,
>          guint signal_id,
>          GQuark detail,
>          ...);
>void g_signal_emit_by_name (gpointer instance,
>          const gchar *detailed_signal,
>          ...);
>guint g_signal_lookup (const gchar *name,
>          GType itype);
> gchar* g_signal_name (guint signal_id);
>void g_signal_query (guint signal_id,
>          GSignalQuery *query);
>guint* g_signal_list_ids (GType itype,
>          guint *n_ids);
>gboolean g_signal_parse_name (const gchar *detailed_signal,
>          GType itype,
>          guint *signal_id_p,
>          GQuark *detail_p,
>          gboolean force_detail_quark);
>GSignalInvocationHint* g_signal_get_invocation_hint (gpointer instance);
>
>
>
>void g_signal_stop_emission (gpointer instance,
>          guint signal_id,
>          GQuark detail);
>void g_signal_stop_emission_by_name (gpointer instance,
>          const gchar *detailed_signal);
>gulong g_signal_add_emission_hook (guint signal_id,
>          GQuark detail,
>          GSignalEmissionHook hook_func,
>          gpointer hook_data,
>          GDestroyNotify data_destroy);
>void g_signal_remove_emission_hook (guint signal_id,
>          gulong hook_id);
>
>
>
>gboolean g_signal_has_handler_pending (gpointer instance,
>            guint signal_id,
>            GQuark detail,
>            gboolean may_be_blocked);
>gulong g_signal_connect_closure_by_id (gpointer instance,
>            guint signal_id,
>            GQuark detail,
>            GClosure *closure,
>            gboolean after);
>gulong g_signal_connect_closure (gpointer instance,
>            const gchar *detailed_signal,
>            GClosure *closure,
>            gboolean after);
>gulong g_signal_connect_data (gpointer instance,
>            const gchar *detailed_signal,
>            GCallback c_handler,
>            gpointer data,
>            GClosureNotify destroy_data,
>            GConnectFlags connect_flags);
>void g_signal_handler_block (gpointer instance,
>            gulong handler_id);
>void g_signal_handler_unblock (gpointer instance,
>            gulong handler_id);
>void g_signal_handler_disconnect (gpointer instance,
>            gulong handler_id);
>gboolean g_signal_handler_is_connected (gpointer instance,
>            gulong handler_id);
>gulong g_signal_handler_find (gpointer instance,
>            GSignalMatchType mask,
>            guint signal_id,
>            GQuark detail,
>            GClosure *closure,
>            gpointer func,
>            gpointer data);
>guint g_signal_handlers_block_matched (gpointer instance,
>            GSignalMatchType mask,
>            guint signal_id,
>            GQuark detail,
>            GClosure *closure,
>            gpointer func,
>            gpointer data);
>guint g_signal_handlers_unblock_matched (gpointer instance,
>            GSignalMatchType mask,
>            guint signal_id,
>            GQuark detail,
>            GClosure *closure,
>            gpointer func,
>            gpointer data);
>guint g_signal_handlers_disconnect_matched (gpointer instance,
>            GSignalMatchType mask,
>            guint signal_id,
>            GQuark detail,
>            GClosure *closure,
>            gpointer func,
>            gpointer data);
>
>
>
>void g_signal_override_class_closure (guint signal_id,
>            GType instance_type,
>            GClosure *class_closure);
>void g_signal_chain_from_overridden (const GValue *instance_and_params,
>            GValue *return_value);
># 259 "gsignal.h"
>gboolean g_signal_accumulator_true_handled (GSignalInvocationHint *ihint,
>         GValue *return_accu,
>         const GValue *handler_return,
>         gpointer dummy);
>
>
>void g_signal_handlers_destroy (gpointer instance);
>void _g_signals_destroy (GType itype);
>
>
># 30 "gsignal.c" 2
>
># 1 "../glib/gbsearcharray.h" 1
># 23 "../glib/gbsearcharray.h"
># 1 "/usr/include/string.h" 1 3 4
># 28 "/usr/include/string.h" 3 4
>
>
>
>
>
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 34 "/usr/include/string.h" 2 3 4
>
>
>
>
>extern void *memcpy (void *__restrict __dest,
>       __const void *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void *memmove (void *__dest, __const void *__src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
>        int __c, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>extern void *memset (void *__s, int __c, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void *memchr (__const void *__s, int __c, size_t __n)
>      __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
># 82 "/usr/include/string.h" 3 4
>
>
>extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncpy (char *__restrict __dest,
>        __const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
>        size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcmp (__const char *__s1, __const char *__s2)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strcoll (__const char *__s1, __const char *__s2)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern size_t strxfrm (char *__restrict __dest,
>         __const char *__restrict __src, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
># 130 "/usr/include/string.h" 3 4
>extern char *strdup (__const char *__s)
>     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
># 165 "/usr/include/string.h" 3 4
>
>
>extern char *strchr (__const char *__s, int __c)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>extern char *strrchr (__const char *__s, int __c)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
># 181 "/usr/include/string.h" 3 4
>
>
>
>extern size_t strcspn (__const char *__s, __const char *__reject)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern size_t strspn (__const char *__s, __const char *__accept)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strpbrk (__const char *__s, __const char *__accept)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>extern char *strstr (__const char *__haystack, __const char *__needle)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern char *__strtok_r (char *__restrict __s,
>    __const char *__restrict __delim,
>    char **__restrict __save_ptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
>
>extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
>         char **__restrict __save_ptr)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
># 240 "/usr/include/string.h" 3 4
>
>
>extern size_t strlen (__const char *__s)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
># 254 "/usr/include/string.h" 3 4
>
>
>extern char *strerror (int __errnum) __attribute__ ((__nothrow__));
>
># 270 "/usr/include/string.h" 3 4
>extern int strerror_r (int __errnum, char *__buf, size_t __buflen) __asm__ ("" "__xpg_strerror_r") __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
># 294 "/usr/include/string.h" 3 4
>extern void __bzero (void *__s, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern void bcopy (__const void *__src, void *__dest, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern void bzero (void *__s, size_t __n) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern char *index (__const char *__s, int __c)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern char *rindex (__const char *__s, int __c)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int ffs (int __i) __attribute__ ((__nothrow__)) __attribute__ ((__const__));
># 331 "/usr/include/string.h" 3 4
>extern int strcasecmp (__const char *__s1, __const char *__s2)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
>
>
>extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
># 354 "/usr/include/string.h" 3 4
>extern char *strsep (char **__restrict __stringp,
>       __const char *__restrict __delim)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
># 420 "/usr/include/string.h" 3 4
># 1 "/usr/include/bits/string.h" 1 3 4
># 421 "/usr/include/string.h" 2 3 4
>
>
># 1 "/usr/include/bits/string2.h" 1 3 4
># 80 "/usr/include/bits/string2.h" 3 4
>typedef struct { unsigned char __arr[2]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR2;
>typedef struct { unsigned char __arr[3]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR3;
>typedef struct { unsigned char __arr[4]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR4;
>typedef struct { unsigned char __arr[5]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR5;
>typedef struct { unsigned char __arr[6]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR6;
>typedef struct { unsigned char __arr[7]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR7;
>typedef struct { unsigned char __arr[8]; } __attribute__ ((__packed__)) __STRING2_COPY_ARR8;
># 394 "/usr/include/bits/string2.h" 3 4
>extern void *__rawmemchr (const void *__s, int __c);
># 969 "/usr/include/bits/string2.h" 3 4
>extern __inline size_t __strcspn_c1 (__const char *__s, int __reject);
>extern __inline size_t
>__strcspn_c1 (__const char *__s, int __reject)
>{
>  register size_t __result = 0;
>  while (__s[__result] != '\0' && __s[__result] != __reject)
>    ++__result;
>  return __result;
>}
>
>extern __inline size_t __strcspn_c2 (__const char *__s, int __reject1,
>         int __reject2);
>extern __inline size_t
>__strcspn_c2 (__const char *__s, int __reject1, int __reject2)
>{
>  register size_t __result = 0;
>  while (__s[__result] != '\0' && __s[__result] != __reject1
>  && __s[__result] != __reject2)
>    ++__result;
>  return __result;
>}
>
>extern __inline size_t __strcspn_c3 (__const char *__s, int __reject1,
>         int __reject2, int __reject3);
>extern __inline size_t
>__strcspn_c3 (__const char *__s, int __reject1, int __reject2,
>       int __reject3)
>{
>  register size_t __result = 0;
>  while (__s[__result] != '\0' && __s[__result] != __reject1
>  && __s[__result] != __reject2 && __s[__result] != __reject3)
>    ++__result;
>  return __result;
>}
># 1045 "/usr/include/bits/string2.h" 3 4
>extern __inline size_t __strspn_c1 (__const char *__s, int __accept);
>extern __inline size_t
>__strspn_c1 (__const char *__s, int __accept)
>{
>  register size_t __result = 0;
>
>  while (__s[__result] == __accept)
>    ++__result;
>  return __result;
>}
>
>extern __inline size_t __strspn_c2 (__const char *__s, int __accept1,
>        int __accept2);
>extern __inline size_t
>__strspn_c2 (__const char *__s, int __accept1, int __accept2)
>{
>  register size_t __result = 0;
>
>  while (__s[__result] == __accept1 || __s[__result] == __accept2)
>    ++__result;
>  return __result;
>}
>
>extern __inline size_t __strspn_c3 (__const char *__s, int __accept1,
>        int __accept2, int __accept3);
>extern __inline size_t
>__strspn_c3 (__const char *__s, int __accept1, int __accept2, int __accept3)
>{
>  register size_t __result = 0;
>
>  while (__s[__result] == __accept1 || __s[__result] == __accept2
>  || __s[__result] == __accept3)
>    ++__result;
>  return __result;
>}
># 1121 "/usr/include/bits/string2.h" 3 4
>extern __inline char *__strpbrk_c2 (__const char *__s, int __accept1,
>         int __accept2);
>extern __inline char *
>__strpbrk_c2 (__const char *__s, int __accept1, int __accept2)
>{
>
>  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2)
>    ++__s;
>  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
>}
>
>extern __inline char *__strpbrk_c3 (__const char *__s, int __accept1,
>         int __accept2, int __accept3);
>extern __inline char *
>__strpbrk_c3 (__const char *__s, int __accept1, int __accept2,
>       int __accept3)
>{
>
>  while (*__s != '\0' && *__s != __accept1 && *__s != __accept2
>  && *__s != __accept3)
>    ++__s;
>  return *__s == '\0' ? ((void *)0) : (char *) (size_t) __s;
>}
># 1172 "/usr/include/bits/string2.h" 3 4
>extern __inline char *__strtok_r_1c (char *__s, char __sep, char **__nextp);
>extern __inline char *
>__strtok_r_1c (char *__s, char __sep, char **__nextp)
>{
>  char *__result;
>  if (__s == ((void *)0))
>    __s = *__nextp;
>  while (*__s == __sep)
>    ++__s;
>  __result = ((void *)0);
>  if (*__s != '\0')
>    {
>      __result = __s++;
>      while (*__s != '\0')
> if (*__s++ == __sep)
>   {
>     __s[-1] = '\0';
>     break;
>   }
>    }
>  *__nextp = __s;
>  return __result;
>}
># 1204 "/usr/include/bits/string2.h" 3 4
>extern char *__strsep_g (char **__stringp, __const char *__delim);
># 1222 "/usr/include/bits/string2.h" 3 4
>extern __inline char *__strsep_1c (char **__s, char __reject);
>extern __inline char *
>__strsep_1c (char **__s, char __reject)
>{
>  register char *__retval = *__s;
>  if (__retval != ((void *)0) && (*__s = (__extension__ (__builtin_constant_p (__reject) && !__builtin_constant_p (__retval) && (__reject) == '\0' ? (char *) __rawmemchr (__retval, __reject) : __builtin_strchr (__retval, __reject)))) != ((void *)0))
>    *(*__s)++ = '\0';
>  return __retval;
>}
>
>extern __inline char *__strsep_2c (char **__s, char __reject1, char __reject2);
>extern __inline char *
>__strsep_2c (char **__s, char __reject1, char __reject2)
>{
>  register char *__retval = *__s;
>  if (__retval != ((void *)0))
>    {
>      register char *__cp = __retval;
>      while (1)
> {
>   if (*__cp == '\0')
>     {
>       __cp = ((void *)0);
>   break;
>     }
>   if (*__cp == __reject1 || *__cp == __reject2)
>     {
>       *__cp++ = '\0';
>       break;
>     }
>   ++__cp;
> }
>      *__s = __cp;
>    }
>  return __retval;
>}
>
>extern __inline char *__strsep_3c (char **__s, char __reject1, char __reject2,
>       char __reject3);
>extern __inline char *
>__strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
>{
>  register char *__retval = *__s;
>  if (__retval != ((void *)0))
>    {
>      register char *__cp = __retval;
>      while (1)
> {
>   if (*__cp == '\0')
>     {
>       __cp = ((void *)0);
>   break;
>     }
>   if (*__cp == __reject1 || *__cp == __reject2 || *__cp == __reject3)
>     {
>       *__cp++ = '\0';
>       break;
>     }
>   ++__cp;
> }
>      *__s = __cp;
>    }
>  return __retval;
>}
># 1298 "/usr/include/bits/string2.h" 3 4
># 1 "/usr/include/stdlib.h" 1 3 4
># 33 "/usr/include/stdlib.h" 3 4
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 34 "/usr/include/stdlib.h" 2 3 4
>
>
># 469 "/usr/include/stdlib.h" 3 4
>
>
>extern void *malloc (size_t __size) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
>extern void *calloc (size_t __nmemb, size_t __size)
>     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
>
># 891 "/usr/include/stdlib.h" 3 4
>
># 1299 "/usr/include/bits/string2.h" 2 3 4
>
>
>
>
>extern char *__strdup (__const char *__string) __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));
># 1322 "/usr/include/bits/string2.h" 3 4
>extern char *__strndup (__const char *__string, size_t __n)
>     __attribute__ ((__nothrow__)) __attribute__ ((__malloc__));
># 424 "/usr/include/string.h" 2 3 4
>
>
>
>
># 1 "/usr/include/bits/string3.h" 1 3 4
># 23 "/usr/include/bits/string3.h" 3 4
>extern void __warn_memset_zero_len (void) __attribute__((__warning__ ("memset used with constant zero length parameter; this could be due to transposed parameters")));
># 48 "/usr/include/bits/string3.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) void *
>__attribute__ ((__nothrow__)) memcpy (void *__restrict __dest, __const void *__restrict __src, size_t __len)
>
>{
>  return __builtin___memcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
>}
>
>extern __inline __attribute__ ((__always_inline__)) void *
>__attribute__ ((__nothrow__)) memmove (void *__restrict __dest, __const void *__restrict __src, size_t __len)
>
>{
>  return __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
>}
># 77 "/usr/include/bits/string3.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) void *
>__attribute__ ((__nothrow__)) memset (void *__dest, int __ch, size_t __len)
>{
>  if (__builtin_constant_p (__len) && __len == 0)
>    {
>      __warn_memset_zero_len ();
>      return __dest;
>    }
>  return __builtin___memset_chk (__dest, __ch, __len, __builtin_object_size (__dest, 0));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) void
>__attribute__ ((__nothrow__)) bcopy (__const void *__restrict __src, void *__restrict __dest, size_t __len)
>
>{
>  (void) __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
>}
>
>extern __inline __attribute__ ((__always_inline__)) void
>__attribute__ ((__nothrow__)) bzero (void *__dest, size_t __len)
>{
>  (void) __builtin___memset_chk (__dest, '\0', __len, __builtin_object_size (__dest, 0));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) char *
>__attribute__ ((__nothrow__)) strcpy (char *__restrict __dest, __const char *__restrict __src)
>{
>  return __builtin___strcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
>}
># 118 "/usr/include/bits/string3.h" 3 4
>extern __inline __attribute__ ((__always_inline__)) char *
>__attribute__ ((__nothrow__)) strncpy (char *__restrict __dest, __const char *__restrict __src, size_t __len)
>
>{
>  return __builtin___strncpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
>}
>
>
>extern char *__stpncpy_chk (char *__dest, __const char *__src, size_t __n,
>       size_t __destlen) __attribute__ ((__nothrow__));
>extern char *__stpncpy_alias (char *__dest, __const char *__src, size_t __n) __asm__ ("" "stpncpy") __attribute__ ((__nothrow__));
>
>
>
>extern __inline __attribute__ ((__always_inline__)) char *
>__attribute__ ((__nothrow__)) stpncpy (char *__dest, __const char *__src, size_t __n)
>{
>  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1
>      && (!__builtin_constant_p (__n) || __n <= __builtin_object_size (__dest, 2 > 1)))
>    return __stpncpy_chk (__dest, __src, __n, __builtin_object_size (__dest, 2 > 1));
>  return __stpncpy_alias (__dest, __src, __n);
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) char *
>__attribute__ ((__nothrow__)) strcat (char *__restrict __dest, __const char *__restrict __src)
>{
>  return __builtin___strcat_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
>}
>
>
>extern __inline __attribute__ ((__always_inline__)) char *
>__attribute__ ((__nothrow__)) strncat (char *__restrict __dest, __const char *__restrict __src, size_t __len)
>
>{
>  return __builtin___strncat_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
>}
># 429 "/usr/include/string.h" 2 3 4
>
>
>
>
># 24 "../glib/gbsearcharray.h" 2
>
>
>
># 38 "../glib/gbsearcharray.h"
>typedef gint (*GBSearchCompareFunc) (gconstpointer bsearch_node1,
>                                      gconstpointer bsearch_node2);
>typedef enum
>{
>  G_BSEARCH_ARRAY_ALIGN_POWER2 = 1 << 0,
>  G_BSEARCH_ARRAY_AUTO_SHRINK = 1 << 1
>} GBSearchArrayFlags;
>
>
>
>typedef struct
>{
>  guint sizeof_node;
>  GBSearchCompareFunc cmp_nodes;
>  guint flags;
>} GBSearchConfig;
>typedef union
>{
>  guint n_nodes;
>
>  gpointer alignment_dummy1;
>  glong alignment_dummy2;
>  gdouble alignment_dummy3;
>} GBSearchArray;
>
>
>
>static inline GBSearchArray* g_bsearch_array_create (const GBSearchConfig *bconfig);
>static inline gpointer g_bsearch_array_get_nth (GBSearchArray *barray,
>                                                           const GBSearchConfig *bconfig,
>                                                           guint nth);
>static inline guint g_bsearch_array_get_index (GBSearchArray *barray,
>                                                           const GBSearchConfig *bconfig,
>                                                           gconstpointer node_in_array);
>static inline GBSearchArray* g_bsearch_array_remove (GBSearchArray *barray,
>                                                           const GBSearchConfig *bconfig,
>                                                           guint index);
>
>static inline GBSearchArray* g_bsearch_array_grow (GBSearchArray *barray,
>                                                           const GBSearchConfig *bconfig,
>                                                           guint index);
>
>static inline GBSearchArray* g_bsearch_array_insert (GBSearchArray *barray,
>                                                           const GBSearchConfig *bconfig,
>                                                           gconstpointer key_node);
>
>
>
>static inline GBSearchArray* g_bsearch_array_replace (GBSearchArray *barray,
>                                                           const GBSearchConfig *bconfig,
>                                                           gconstpointer key_node);
>static inline void g_bsearch_array_free (GBSearchArray *barray,
>                                                           const GBSearchConfig *bconfig);
># 125 "../glib/gbsearcharray.h"
>static inline GBSearchArray*
>g_bsearch_array_create (const GBSearchConfig *bconfig)
>{
>  GBSearchArray *barray;
>  guint size;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (bconfig != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "bconfig != NULL"); return (((void *)0)); }; });
>
>  size = sizeof (GBSearchArray) + bconfig->sizeof_node;
>  if (bconfig->flags & G_BSEARCH_ARRAY_ALIGN_POWER2)
>    size = ((size) ? 1 << g_bit_storage ((size) - 1) : 0);
>  barray = (GBSearchArray *) g_realloc (((void *)0), size);
>  memset (barray, 0, sizeof (GBSearchArray));
>
>  return barray;
>}
>static inline gpointer
>g_bsearch_array_lookup_fuzzy (GBSearchArray *barray,
>                              const GBSearchConfig *bconfig,
>                              gconstpointer key_node,
>                              const guint sibling_or_after);
>static inline gpointer
>g_bsearch_array_lookup_fuzzy (GBSearchArray *barray,
>                              const GBSearchConfig *bconfig,
>                              gconstpointer key_node,
>                              const guint sibling_or_after)
>{
>  GBSearchCompareFunc cmp_nodes = bconfig->cmp_nodes;
>  guint8 *check = ((void *)0), *nodes = (((guint8*) (barray)) + sizeof (GBSearchArray));
>  guint n_nodes = barray->n_nodes, offs = 0;
>  guint sizeof_node = bconfig->sizeof_node;
>  gint cmp = 0;
>
>  while (offs < n_nodes)
>    {
>      guint i = (offs + n_nodes) >> 1;
>
>      check = nodes + i * sizeof_node;
>      cmp = cmp_nodes (key_node, check);
>      if (cmp == 0)
>        return sibling_or_after > 1 ? ((void *)0) : check;
>      else if (cmp < 0)
>        n_nodes = i;
>      else
>        offs = i + 1;
>    }
>
>
>  return (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (!sibling_or_after) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) ? ((void *)0) : (sibling_or_after > 1 && cmp > 0) ? check + sizeof_node : check;
>}
>static inline gpointer
>g_bsearch_array_get_nth (GBSearchArray *barray,
>                         const GBSearchConfig *bconfig,
>                         guint nth)
>{
>  return ((__builtin_expect (__extension__ ({ int _g_boolean_var_; if (nth < barray->n_nodes) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) ?
>          (((guint8*) (barray)) + sizeof (GBSearchArray)) + nth * bconfig->sizeof_node :
>          ((void *)0));
>}
>static inline guint
>g_bsearch_array_get_index (GBSearchArray *barray,
>                           const GBSearchConfig *bconfig,
>                           gconstpointer node_in_array)
>{
>  guint distance = ((guint8*) node_in_array) - (((guint8*) (barray)) + sizeof (GBSearchArray));
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (node_in_array != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "node_in_array != NULL"); return (barray->n_nodes); }; });
>
>  distance /= bconfig->sizeof_node;
>
>  return (((distance) < (barray->n_nodes + 1)) ? (distance) : (barray->n_nodes + 1));
>}
>static inline GBSearchArray*
>g_bsearch_array_grow (GBSearchArray *barray,
>                      const GBSearchConfig *bconfig,
>                      guint index)
>{
>  guint old_size = barray->n_nodes * bconfig->sizeof_node;
>  guint new_size = old_size + bconfig->sizeof_node;
>  guint8 *node;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (index <= barray->n_nodes) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "index <= barray->n_nodes"); return (((void *)0)); }; });
>
>  if ((__builtin_expect (__extension__ ({ int _g_boolean_var_; if (bconfig->flags & G_BSEARCH_ARRAY_ALIGN_POWER2) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 0)))
>    {
>      new_size = ((sizeof (GBSearchArray) + new_size) ? 1 << g_bit_storage ((sizeof (GBSearchArray) + new_size) - 1) : 0);
>      old_size = ((sizeof (GBSearchArray) + old_size) ? 1 << g_bit_storage ((sizeof (GBSearchArray) + old_size) - 1) : 0);
>      if (old_size != new_size)
>        barray = (GBSearchArray *) g_realloc (barray, new_size);
>    }
>  else
>    barray = (GBSearchArray *) g_realloc (barray, sizeof (GBSearchArray) + new_size);
>  node = (((guint8*) (barray)) + sizeof (GBSearchArray)) + index * bconfig->sizeof_node;
>  (void) __extension__ ( { memmove ((node + bconfig->sizeof_node), (node), ((barray->n_nodes - index) * bconfig->sizeof_node)); } );
>  barray->n_nodes += 1;
>  return barray;
>}
>static inline GBSearchArray*
>g_bsearch_array_insert (GBSearchArray *barray,
>                        const GBSearchConfig *bconfig,
>                        gconstpointer key_node)
>{
>  guint8 *node;
>
>  if ((__builtin_expect (__extension__ ({ int _g_boolean_var_; if (!barray->n_nodes) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 0)))
>    {
>      barray = g_bsearch_array_grow (barray, bconfig, 0);
>      node = (((guint8*) (barray)) + sizeof (GBSearchArray));
>    }
>  else
>    {
>      node = (guint8 *) g_bsearch_array_lookup_fuzzy ((barray), (bconfig), (key_node), 2);
>      if ((__builtin_expect (__extension__ ({ int _g_boolean_var_; if (node) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)))
>        {
>          guint index = g_bsearch_array_get_index (barray, bconfig, node);
>
>
>          barray = g_bsearch_array_grow (barray, bconfig, index);
>          node = (((guint8*) (barray)) + sizeof (GBSearchArray)) + index * bconfig->sizeof_node;
>        }
>      else
>        return barray;
>    }
>  memcpy (node, key_node, bconfig->sizeof_node);
>  return barray;
>}
>static inline GBSearchArray*
>g_bsearch_array_replace (GBSearchArray *barray,
>                         const GBSearchConfig *bconfig,
>                         gconstpointer key_node)
>{
>  guint8 *node = (guint8 *) g_bsearch_array_lookup_fuzzy ((barray), (bconfig), (key_node), 0);
>  if ((__builtin_expect (__extension__ ({ int _g_boolean_var_; if (node) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)))
>    memcpy (node, key_node, bconfig->sizeof_node);
>  else
>    barray = g_bsearch_array_insert (barray, bconfig, key_node);
>  return barray;
>}
>static inline GBSearchArray*
>g_bsearch_array_remove (GBSearchArray *barray,
>                        const GBSearchConfig *bconfig,
>                        guint index)
>{
>  guint8 *node;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (index < barray->n_nodes) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "index < barray->n_nodes"); return (((void *)0)); }; });
>
>  barray->n_nodes -= 1;
>  node = (((guint8*) (barray)) + sizeof (GBSearchArray)) + index * bconfig->sizeof_node;
>  (void) __extension__ ( { memmove ((node), (node + bconfig->sizeof_node), ((barray->n_nodes - index) * bconfig->sizeof_node)); } );
>  if ((__builtin_expect (__extension__ ({ int _g_boolean_var_; if (bconfig->flags & G_BSEARCH_ARRAY_AUTO_SHRINK) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 0)))
>    {
>      guint new_size = barray->n_nodes * bconfig->sizeof_node;
>      guint old_size = new_size + bconfig->sizeof_node;
>
>      if ((__builtin_expect (__extension__ ({ int _g_boolean_var_; if (bconfig->flags & G_BSEARCH_ARRAY_ALIGN_POWER2) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 0)))
>        {
>          new_size = ((sizeof (GBSearchArray) + new_size) ? 1 << g_bit_storage ((sizeof (GBSearchArray) + new_size) - 1) : 0);
>          old_size = ((sizeof (GBSearchArray) + old_size) ? 1 << g_bit_storage ((sizeof (GBSearchArray) + old_size) - 1) : 0);
>          if (old_size != new_size)
>            barray = (GBSearchArray *) g_realloc (barray, new_size);
>        }
>      else
>        barray = (GBSearchArray *) g_realloc (barray, sizeof (GBSearchArray) + new_size);
>    }
>  return barray;
>}
>static inline void
>g_bsearch_array_free (GBSearchArray *barray,
>                      const GBSearchConfig *bconfig)
>{
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (barray != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "barray != NULL"); return; }; });
>
>  g_free (barray);
>}
>
>
># 32 "gsignal.c" 2
># 1 "gvaluecollector.h" 1
># 24 "gvaluecollector.h"
># 1 "../glib/glib-object.h" 1
># 25 "../glib/glib-object.h"
># 1 "../gobject/gboxed.h" 1
># 26 "../gobject/gboxed.h"
># 1 "../gobject/gtype.h" 1
># 27 "../gobject/gboxed.h" 2
>
>
>
>
>
>
>
>
>
>typedef gpointer (*GBoxedCopyFunc) (gpointer boxed);
>typedef void (*GBoxedFreeFunc) (gpointer boxed);
>
>
>
>gpointer g_boxed_copy (GType boxed_type,
>       gconstpointer src_boxed);
>void g_boxed_free (GType boxed_type,
>       gpointer boxed);
>void g_value_set_boxed (GValue *value,
>       gconstpointer v_boxed);
>void g_value_set_static_boxed (GValue *value,
>       gconstpointer v_boxed);
>gpointer g_value_get_boxed (const GValue *value);
>gpointer g_value_dup_boxed (const GValue *value);
>
>
>
>GType g_boxed_type_register_static (const gchar *name,
>       GBoxedCopyFunc boxed_copy,
>       GBoxedFreeFunc boxed_free);
># 70 "../gobject/gboxed.h"
>void g_value_take_boxed (GValue *value,
>     gconstpointer v_boxed);
>
>
>
>
>GType g_closure_get_type (void) __attribute__((__const__));
>GType g_value_get_type (void) __attribute__((__const__));
>GType g_value_array_get_type (void) __attribute__((__const__));
>GType g_date_get_type (void) __attribute__((__const__));
>GType g_strv_get_type (void) __attribute__((__const__));
>GType g_gstring_get_type (void) __attribute__((__const__));
>GType g_hash_table_get_type (void) __attribute__((__const__));
>GType g_regex_get_type (void) __attribute__((__const__));
>
>typedef gchar** GStrv;
>
>
># 26 "../glib/glib-object.h" 2
># 1 "../gobject/genums.h" 1
># 26 "../gobject/genums.h"
># 1 "../gobject/gtype.h" 1
># 27 "../gobject/genums.h" 2
>
>
># 46 "../gobject/genums.h"
>typedef struct _GEnumClass GEnumClass;
>typedef struct _GFlagsClass GFlagsClass;
>typedef struct _GEnumValue GEnumValue;
>typedef struct _GFlagsValue GFlagsValue;
>struct _GEnumClass
>{
>  GTypeClass g_type_class;
>
>
>  gint minimum;
>  gint maximum;
>  guint n_values;
>  GEnumValue *values;
>};
>struct _GFlagsClass
>{
>  GTypeClass g_type_class;
>
>
>  guint mask;
>  guint n_values;
>  GFlagsValue *values;
>};
>struct _GEnumValue
>{
>  gint value;
>  const gchar *value_name;
>  const gchar *value_nick;
>};
>struct _GFlagsValue
>{
>  guint value;
>  const gchar *value_name;
>  const gchar *value_nick;
>};
>
>
>
>GEnumValue* g_enum_get_value (GEnumClass *enum_class,
>       gint value);
>GEnumValue* g_enum_get_value_by_name (GEnumClass *enum_class,
>       const gchar *name);
>GEnumValue* g_enum_get_value_by_nick (GEnumClass *enum_class,
>       const gchar *nick);
>GFlagsValue* g_flags_get_first_value (GFlagsClass *flags_class,
>       guint value);
>GFlagsValue* g_flags_get_value_by_name (GFlagsClass *flags_class,
>       const gchar *name);
>GFlagsValue* g_flags_get_value_by_nick (GFlagsClass *flags_class,
>       const gchar *nick);
>void g_value_set_enum (GValue *value,
>       gint v_enum);
>gint g_value_get_enum (const GValue *value);
>void g_value_set_flags (GValue *value,
>       guint v_flags);
>guint g_value_get_flags (const GValue *value);
>
>
>
>
>
>
>
>GType g_enum_register_static (const gchar *name,
>        const GEnumValue *const_static_values);
>GType g_flags_register_static (const gchar *name,
>        const GFlagsValue *const_static_values);
>
>
>
>void g_enum_complete_type_info (GType g_enum_type,
>        GTypeInfo *info,
>        const GEnumValue *const_values);
>void g_flags_complete_type_info (GType g_flags_type,
>        GTypeInfo *info,
>        const GFlagsValue *const_values);
>
>
># 27 "../glib/glib-object.h" 2
># 1 "../gobject/gobject.h" 1
># 26 "../gobject/gobject.h"
># 1 "../gobject/gtype.h" 1
># 27 "../gobject/gobject.h" 2
># 1 "../gobject/gvalue.h" 1
># 28 "../gobject/gobject.h" 2
># 1 "../gobject/gparam.h" 1
># 29 "../gobject/gobject.h" 2
># 1 "../gobject/gclosure.h" 1
># 30 "../gobject/gobject.h" 2
># 1 "../gobject/gsignal.h" 1
># 31 "../gobject/gobject.h" 2
>
>
># 58 "../gobject/gobject.h"
>typedef struct _GObject GObject;
>typedef struct _GObjectClass GObjectClass;
>typedef struct _GObject GInitiallyUnowned;
>typedef struct _GObjectClass GInitiallyUnownedClass;
>typedef struct _GObjectConstructParam GObjectConstructParam;
>typedef void (*GObjectGetPropertyFunc) (GObject *object,
>                                         guint property_id,
>                                         GValue *value,
>                                         GParamSpec *pspec);
>typedef void (*GObjectSetPropertyFunc) (GObject *object,
>                                         guint property_id,
>                                         const GValue *value,
>                                         GParamSpec *pspec);
>typedef void (*GObjectFinalizeFunc) (GObject *object);
>typedef void (*GWeakNotify) (gpointer data,
>      GObject *where_the_object_was);
>struct _GObject
>{
>  GTypeInstance g_type_instance;
>
>
>  volatile guint ref_count;
>  GData *qdata;
>};
>struct _GObjectClass
>{
>  GTypeClass g_type_class;
>
>
>  GSList *construct_properties;
>
>
>
>  GObject* (*constructor) (GType type,
>                                 guint n_construct_properties,
>                                 GObjectConstructParam *construct_properties);
>
>  void (*set_property) (GObject *object,
>                                         guint property_id,
>                                         const GValue *value,
>                                         GParamSpec *pspec);
>  void (*get_property) (GObject *object,
>                                         guint property_id,
>                                         GValue *value,
>                                         GParamSpec *pspec);
>  void (*dispose) (GObject *object);
>  void (*finalize) (GObject *object);
>
>  void (*dispatch_properties_changed) (GObject *object,
>          guint n_pspecs,
>          GParamSpec **pspecs);
>
>  void (*notify) (GObject *object,
>      GParamSpec *pspec);
>
>
>  void (*constructed) (GObject *object);
>
>
>
>  gpointer pdummy[7];
>};
>struct _GObjectConstructParam
>{
>  GParamSpec *pspec;
>  GValue *value;
>};
>
>
>
>GType g_initially_unowned_get_type (void);
>void g_object_class_install_property (GObjectClass *oclass,
>            guint property_id,
>            GParamSpec *pspec);
>GParamSpec* g_object_class_find_property (GObjectClass *oclass,
>            const gchar *property_name);
>GParamSpec**g_object_class_list_properties (GObjectClass *oclass,
>            guint *n_properties);
>void g_object_class_override_property (GObjectClass *oclass,
>            guint property_id,
>            const gchar *name);
>
>void g_object_interface_install_property (gpointer g_iface,
>       GParamSpec *pspec);
>GParamSpec* g_object_interface_find_property (gpointer g_iface,
>       const gchar *property_name);
>GParamSpec**g_object_interface_list_properties (gpointer g_iface,
>       guint *n_properties_p);
>
>gpointer g_object_new (GType object_type,
>            const gchar *first_property_name,
>            ...);
>gpointer g_object_newv (GType object_type,
>            guint n_parameters,
>            GParameter *parameters);
>GObject* g_object_new_valist (GType object_type,
>            const gchar *first_property_name,
>            va_list var_args);
>void g_object_set (gpointer object,
>            const gchar *first_property_name,
>            ...) __attribute__((__sentinel__));
>void g_object_get (gpointer object,
>            const gchar *first_property_name,
>            ...) __attribute__((__sentinel__));
>gpointer g_object_connect (gpointer object,
>            const gchar *signal_spec,
>            ...) __attribute__((__sentinel__));
>void g_object_disconnect (gpointer object,
>            const gchar *signal_spec,
>            ...) __attribute__((__sentinel__));
>void g_object_set_valist (GObject *object,
>            const gchar *first_property_name,
>            va_list var_args);
>void g_object_get_valist (GObject *object,
>            const gchar *first_property_name,
>            va_list var_args);
>void g_object_set_property (GObject *object,
>            const gchar *property_name,
>            const GValue *value);
>void g_object_get_property (GObject *object,
>            const gchar *property_name,
>            GValue *value);
>void g_object_freeze_notify (GObject *object);
>void g_object_notify (GObject *object,
>            const gchar *property_name);
>void g_object_thaw_notify (GObject *object);
>gboolean g_object_is_floating (gpointer object);
>gpointer g_object_ref_sink (gpointer object);
>gpointer g_object_ref (gpointer object);
>void g_object_unref (gpointer object);
>void g_object_weak_ref (GObject *object,
>            GWeakNotify notify,
>            gpointer data);
>void g_object_weak_unref (GObject *object,
>            GWeakNotify notify,
>            gpointer data);
>void g_object_add_weak_pointer (GObject *object,
>                                               gpointer *weak_pointer_location);
>void g_object_remove_weak_pointer (GObject *object,
>                                               gpointer *weak_pointer_location);
>
>typedef void (*GToggleNotify) (gpointer data,
>          GObject *object,
>          gboolean is_last_ref);
>
>void g_object_add_toggle_ref (GObject *object,
>     GToggleNotify notify,
>     gpointer data);
>void g_object_remove_toggle_ref (GObject *object,
>     GToggleNotify notify,
>     gpointer data);
>
>gpointer g_object_get_qdata (GObject *object,
>            GQuark quark);
>void g_object_set_qdata (GObject *object,
>            GQuark quark,
>            gpointer data);
>void g_object_set_qdata_full (GObject *object,
>            GQuark quark,
>            gpointer data,
>            GDestroyNotify destroy);
>gpointer g_object_steal_qdata (GObject *object,
>            GQuark quark);
>gpointer g_object_get_data (GObject *object,
>            const gchar *key);
>void g_object_set_data (GObject *object,
>            const gchar *key,
>            gpointer data);
>void g_object_set_data_full (GObject *object,
>            const gchar *key,
>            gpointer data,
>            GDestroyNotify destroy);
>gpointer g_object_steal_data (GObject *object,
>            const gchar *key);
>void g_object_watch_closure (GObject *object,
>            GClosure *closure);
>GClosure* g_cclosure_new_object (GCallback callback_func,
>            GObject *object);
>GClosure* g_cclosure_new_object_swap (GCallback callback_func,
>            GObject *object);
>GClosure* g_closure_new_object (guint sizeof_closure,
>            GObject *object);
>void g_value_set_object (GValue *value,
>            gpointer v_object);
>gpointer g_value_get_object (const GValue *value);
>gpointer g_value_dup_object (const GValue *value);
>gulong g_signal_connect_object (gpointer instance,
>            const gchar *detailed_signal,
>            GCallback c_handler,
>            gpointer gobject,
>            GConnectFlags connect_flags);
>
>
>void g_object_force_floating (GObject *object);
>void g_object_run_dispose (GObject *object);
>
>
>void g_value_take_object (GValue *value,
>            gpointer v_object);
># 284 "../gobject/gobject.h"
>
># 28 "../glib/glib-object.h" 2
># 1 "../gobject/gparam.h" 1
># 29 "../glib/glib-object.h" 2
># 1 "../gobject/gparamspecs.h" 1
># 28 "../gobject/gparamspecs.h"
># 1 "../gobject/gvalue.h" 1
># 29 "../gobject/gparamspecs.h" 2
># 1 "../gobject/genums.h" 1
># 30 "../gobject/gparamspecs.h" 2
># 1 "../gobject/gboxed.h" 1
># 31 "../gobject/gparamspecs.h" 2
># 1 "../gobject/gobject.h" 1
># 32 "../gobject/gparamspecs.h" 2
>
>
># 105 "../gobject/gparamspecs.h"
>typedef struct _GParamSpecChar GParamSpecChar;
>typedef struct _GParamSpecUChar GParamSpecUChar;
>typedef struct _GParamSpecBoolean GParamSpecBoolean;
>typedef struct _GParamSpecInt GParamSpecInt;
>typedef struct _GParamSpecUInt GParamSpecUInt;
>typedef struct _GParamSpecLong GParamSpecLong;
>typedef struct _GParamSpecULong GParamSpecULong;
>typedef struct _GParamSpecInt64 GParamSpecInt64;
>typedef struct _GParamSpecUInt64 GParamSpecUInt64;
>typedef struct _GParamSpecUnichar GParamSpecUnichar;
>typedef struct _GParamSpecEnum GParamSpecEnum;
>typedef struct _GParamSpecFlags GParamSpecFlags;
>typedef struct _GParamSpecFloat GParamSpecFloat;
>typedef struct _GParamSpecDouble GParamSpecDouble;
>typedef struct _GParamSpecString GParamSpecString;
>typedef struct _GParamSpecParam GParamSpecParam;
>typedef struct _GParamSpecBoxed GParamSpecBoxed;
>typedef struct _GParamSpecPointer GParamSpecPointer;
>typedef struct _GParamSpecValueArray GParamSpecValueArray;
>typedef struct _GParamSpecObject GParamSpecObject;
>typedef struct _GParamSpecOverride GParamSpecOverride;
>typedef struct _GParamSpecGType GParamSpecGType;
>
>struct _GParamSpecChar
>{
>  GParamSpec parent_instance;
>
>  gint8 minimum;
>  gint8 maximum;
>  gint8 default_value;
>};
>struct _GParamSpecUChar
>{
>  GParamSpec parent_instance;
>
>  guint8 minimum;
>  guint8 maximum;
>  guint8 default_value;
>};
>struct _GParamSpecBoolean
>{
>  GParamSpec parent_instance;
>
>  gboolean default_value;
>};
>struct _GParamSpecInt
>{
>  GParamSpec parent_instance;
>
>  gint minimum;
>  gint maximum;
>  gint default_value;
>};
>struct _GParamSpecUInt
>{
>  GParamSpec parent_instance;
>
>  guint minimum;
>  guint maximum;
>  guint default_value;
>};
>struct _GParamSpecLong
>{
>  GParamSpec parent_instance;
>
>  glong minimum;
>  glong maximum;
>  glong default_value;
>};
>struct _GParamSpecULong
>{
>  GParamSpec parent_instance;
>
>  gulong minimum;
>  gulong maximum;
>  gulong default_value;
>};
>struct _GParamSpecInt64
>{
>  GParamSpec parent_instance;
>
>  gint64 minimum;
>  gint64 maximum;
>  gint64 default_value;
>};
>struct _GParamSpecUInt64
>{
>  GParamSpec parent_instance;
>
>  guint64 minimum;
>  guint64 maximum;
>  guint64 default_value;
>};
>struct _GParamSpecUnichar
>{
>  GParamSpec parent_instance;
>
>  gunichar default_value;
>};
>struct _GParamSpecEnum
>{
>  GParamSpec parent_instance;
>
>  GEnumClass *enum_class;
>  gint default_value;
>};
>struct _GParamSpecFlags
>{
>  GParamSpec parent_instance;
>
>  GFlagsClass *flags_class;
>  guint default_value;
>};
>struct _GParamSpecFloat
>{
>  GParamSpec parent_instance;
>
>  gfloat minimum;
>  gfloat maximum;
>  gfloat default_value;
>  gfloat epsilon;
>};
>struct _GParamSpecDouble
>{
>  GParamSpec parent_instance;
>
>  gdouble minimum;
>  gdouble maximum;
>  gdouble default_value;
>  gdouble epsilon;
>};
>struct _GParamSpecString
>{
>  GParamSpec parent_instance;
>
>  gchar *default_value;
>  gchar *cset_first;
>  gchar *cset_nth;
>  gchar substitutor;
>  guint null_fold_if_empty : 1;
>  guint ensure_non_null : 1;
>};
>struct _GParamSpecParam
>{
>  GParamSpec parent_instance;
>};
>struct _GParamSpecBoxed
>{
>  GParamSpec parent_instance;
>};
>struct _GParamSpecPointer
>{
>  GParamSpec parent_instance;
>};
>struct _GParamSpecValueArray
>{
>  GParamSpec parent_instance;
>  GParamSpec *element_spec;
>  guint fixed_n_elements;
>};
>struct _GParamSpecObject
>{
>  GParamSpec parent_instance;
>};
>struct _GParamSpecOverride
>{
>
>  GParamSpec parent_instance;
>  GParamSpec *overridden;
>};
>struct _GParamSpecGType
>{
>  GParamSpec parent_instance;
>  GType is_a_type;
>};
>
>
>GParamSpec* g_param_spec_char (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       gint8 minimum,
>       gint8 maximum,
>       gint8 default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_uchar (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       guint8 minimum,
>       guint8 maximum,
>       guint8 default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_boolean (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       gboolean default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_int (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       gint minimum,
>       gint maximum,
>       gint default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_uint (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       guint minimum,
>       guint maximum,
>       guint default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_long (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       glong minimum,
>       glong maximum,
>       glong default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_ulong (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       gulong minimum,
>       gulong maximum,
>       gulong default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_int64 (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       gint64 minimum,
>       gint64 maximum,
>       gint64 default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_uint64 (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       guint64 minimum,
>       guint64 maximum,
>       guint64 default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_unichar (const gchar *name,
>              const gchar *nick,
>              const gchar *blurb,
>              gunichar default_value,
>              GParamFlags flags);
>GParamSpec* g_param_spec_enum (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       GType enum_type,
>       gint default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_flags (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       GType flags_type,
>       guint default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_float (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       gfloat minimum,
>       gfloat maximum,
>       gfloat default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_double (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       gdouble minimum,
>       gdouble maximum,
>       gdouble default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_string (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       const gchar *default_value,
>       GParamFlags flags);
>GParamSpec* g_param_spec_param (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       GType param_type,
>       GParamFlags flags);
>GParamSpec* g_param_spec_boxed (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       GType boxed_type,
>       GParamFlags flags);
>GParamSpec* g_param_spec_pointer (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       GParamFlags flags);
>GParamSpec* g_param_spec_value_array (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       GParamSpec *element_spec,
>       GParamFlags flags);
>GParamSpec* g_param_spec_object (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       GType object_type,
>       GParamFlags flags);
>GParamSpec* g_param_spec_override (const gchar *name,
>       GParamSpec *overridden);
>GParamSpec* g_param_spec_gtype (const gchar *name,
>       const gchar *nick,
>       const gchar *blurb,
>       GType is_a_type,
>       GParamFlags flags);
># 435 "../gobject/gparamspecs.h"
>extern GType *g_param_spec_types;
>
>
># 30 "../glib/glib-object.h" 2
># 1 "../gobject/gsignal.h" 1
># 31 "../glib/glib-object.h" 2
># 1 "../gobject/gsourceclosure.h" 1
># 26 "../gobject/gsourceclosure.h"
># 1 "../gobject/gclosure.h" 1
># 27 "../gobject/gsourceclosure.h" 2
>
>
>
>void g_source_set_closure (GSource *source,
>      GClosure *closure);
>
>GType g_io_channel_get_type (void);
>GType g_io_condition_get_type (void);
>
>
>
>
>
># 32 "../glib/glib-object.h" 2
># 1 "../gobject/gtype.h" 1
># 33 "../glib/glib-object.h" 2
># 1 "../gobject/gtypemodule.h" 1
># 26 "../gobject/gtypemodule.h"
># 1 "../gobject/gobject.h" 1
># 27 "../gobject/gtypemodule.h" 2
># 1 "../gobject/genums.h" 1
># 28 "../gobject/gtypemodule.h" 2
>
>
>
>typedef struct _GTypeModule GTypeModule;
>typedef struct _GTypeModuleClass GTypeModuleClass;
># 41 "../gobject/gtypemodule.h"
>struct _GTypeModule
>{
>  GObject parent_instance;
>
>  guint use_count;
>  GSList *type_infos;
>  GSList *interface_infos;
>
>
>  gchar *name;
>};
>
>struct _GTypeModuleClass
>{
>  GObjectClass parent_class;
>
>
>  gboolean (* load) (GTypeModule *module);
>  void (* unload) (GTypeModule *module);
>
>
>
>  void (*reserved1) (void);
>  void (*reserved2) (void);
>  void (*reserved3) (void);
>  void (*reserved4) (void);
>};
># 112 "../gobject/gtypemodule.h"
>GType g_type_module_get_type (void) __attribute__((__const__));
>gboolean g_type_module_use (GTypeModule *module);
>void g_type_module_unuse (GTypeModule *module);
>void g_type_module_set_name (GTypeModule *module,
>                                       const gchar *name);
>GType g_type_module_register_type (GTypeModule *module,
>                                       GType parent_type,
>                                       const gchar *type_name,
>                                       const GTypeInfo *type_info,
>                                       GTypeFlags flags);
>void g_type_module_add_interface (GTypeModule *module,
>                                       GType instance_type,
>                                       GType interface_type,
>                                       const GInterfaceInfo *interface_info);
>GType g_type_module_register_enum (GTypeModule *module,
>                                       const gchar *name,
>                                       const GEnumValue *const_static_values);
>GType g_type_module_register_flags (GTypeModule *module,
>                                       const gchar *name,
>                                       const GFlagsValue *const_static_values);
>
>
># 34 "../glib/glib-object.h" 2
># 1 "../gobject/gtypeplugin.h" 1
># 26 "../gobject/gtypeplugin.h"
># 1 "../gobject/gtype.h" 1
># 27 "../gobject/gtypeplugin.h" 2
>
>
># 40 "../gobject/gtypeplugin.h"
>typedef struct _GTypePluginClass GTypePluginClass;
>typedef void (*GTypePluginUse) (GTypePlugin *plugin);
>typedef void (*GTypePluginUnuse) (GTypePlugin *plugin);
>typedef void (*GTypePluginCompleteTypeInfo) (GTypePlugin *plugin,
>         GType g_type,
>         GTypeInfo *info,
>         GTypeValueTable *value_table);
>typedef void (*GTypePluginCompleteInterfaceInfo) (GTypePlugin *plugin,
>         GType instance_type,
>         GType interface_type,
>         GInterfaceInfo *info);
>struct _GTypePluginClass
>{
>
>  GTypeInterface base_iface;
>
>
>  GTypePluginUse use_plugin;
>  GTypePluginUnuse unuse_plugin;
>  GTypePluginCompleteTypeInfo complete_type_info;
>  GTypePluginCompleteInterfaceInfo complete_interface_info;
>};
>
>
>
>GType g_type_plugin_get_type (void) __attribute__((__const__));
>void g_type_plugin_use (GTypePlugin *plugin);
>void g_type_plugin_unuse (GTypePlugin *plugin);
>void g_type_plugin_complete_type_info (GTypePlugin *plugin,
>       GType g_type,
>       GTypeInfo *info,
>       GTypeValueTable *value_table);
>void g_type_plugin_complete_interface_info (GTypePlugin *plugin,
>       GType instance_type,
>       GType interface_type,
>       GInterfaceInfo *info);
>
>
># 35 "../glib/glib-object.h" 2
># 1 "../gobject/gvalue.h" 1
># 36 "../glib/glib-object.h" 2
># 1 "../gobject/gvaluearray.h" 1
># 28 "../gobject/gvaluearray.h"
># 1 "../gobject/gvalue.h" 1
># 29 "../gobject/gvaluearray.h" 2
>
>
>
>
>
>
>typedef struct _GValueArray GValueArray;
>struct _GValueArray
>{
>  guint n_values;
>  GValue *values;
>
>
>  guint n_prealloced;
>};
>
>
>
>GValue* g_value_array_get_nth (GValueArray *value_array,
>           guint index_);
>GValueArray* g_value_array_new (guint n_prealloced);
>void g_value_array_free (GValueArray *value_array);
>GValueArray* g_value_array_copy (const GValueArray *value_array);
>GValueArray* g_value_array_prepend (GValueArray *value_array,
>           const GValue *value);
>GValueArray* g_value_array_append (GValueArray *value_array,
>           const GValue *value);
>GValueArray* g_value_array_insert (GValueArray *value_array,
>           guint index_,
>           const GValue *value);
>GValueArray* g_value_array_remove (GValueArray *value_array,
>           guint index_);
>GValueArray* g_value_array_sort (GValueArray *value_array,
>           GCompareFunc compare_func);
>GValueArray* g_value_array_sort_with_data (GValueArray *value_array,
>           GCompareDataFunc compare_func,
>           gpointer user_data);
>
>
>
># 37 "../glib/glib-object.h" 2
># 1 "../gobject/gvaluetypes.h" 1
># 28 "../gobject/gvaluetypes.h"
># 1 "../gobject/gvalue.h" 1
># 29 "../gobject/gvaluetypes.h" 2
>
>
># 51 "../gobject/gvaluetypes.h"
>void g_value_set_char (GValue *value,
>       gchar v_char);
>gchar g_value_get_char (const GValue *value);
>void g_value_set_uchar (GValue *value,
>       guchar v_uchar);
>guchar g_value_get_uchar (const GValue *value);
>void g_value_set_boolean (GValue *value,
>       gboolean v_boolean);
>gboolean g_value_get_boolean (const GValue *value);
>void g_value_set_int (GValue *value,
>       gint v_int);
>gint g_value_get_int (const GValue *value);
>void g_value_set_uint (GValue *value,
>       guint v_uint);
>guint g_value_get_uint (const GValue *value);
>void g_value_set_long (GValue *value,
>       glong v_long);
>glong g_value_get_long (const GValue *value);
>void g_value_set_ulong (GValue *value,
>       gulong v_ulong);
>gulong g_value_get_ulong (const GValue *value);
>void g_value_set_int64 (GValue *value,
>       gint64 v_int64);
>gint64 g_value_get_int64 (const GValue *value);
>void g_value_set_uint64 (GValue *value,
>       guint64 v_uint64);
>guint64 g_value_get_uint64 (const GValue *value);
>void g_value_set_float (GValue *value,
>       gfloat v_float);
>gfloat g_value_get_float (const GValue *value);
>void g_value_set_double (GValue *value,
>       gdouble v_double);
>gdouble g_value_get_double (const GValue *value);
>void g_value_set_string (GValue *value,
>       const gchar *v_string);
>void g_value_set_static_string (GValue *value,
>       const gchar *v_string);
> gchar* g_value_get_string (const GValue *value);
>gchar* g_value_dup_string (const GValue *value);
>void g_value_set_pointer (GValue *value,
>       gpointer v_pointer);
>gpointer g_value_get_pointer (const GValue *value);
>GType g_gtype_get_type (void);
>void g_value_set_gtype (GValue *value,
>       GType v_gtype);
>GType g_value_get_gtype (const GValue *value);
>
>
>
>GType g_pointer_type_register_static (const gchar *name);
>
>
>gchar* g_strdup_value_contents (const GValue *value);
>
>
>void g_value_take_string (GValue *value,
>       gchar *v_string);
>
>
>
>
>
>
>
>typedef gchar* gchararray;
>
>
>
># 38 "../glib/glib-object.h" 2
># 25 "gvaluecollector.h" 2
>
>
>
>
>
>
>
>
>enum
>{
>  G_VALUE_COLLECT_INT = 'i',
>  G_VALUE_COLLECT_LONG = 'l',
>  G_VALUE_COLLECT_INT64 = 'q',
>  G_VALUE_COLLECT_DOUBLE = 'd',
>  G_VALUE_COLLECT_POINTER = 'p'
>};
>
>
>
>
>union _GTypeCValue
>{
>  gint v_int;
>  glong v_long;
>  gint64 v_int64;
>  gdouble v_double;
>  gpointer v_pointer;
>};
># 158 "gvaluecollector.h"
>
># 33 "gsignal.c" 2
># 1 "gvaluetypes.h" 1
># 34 "gsignal.c" 2
># 1 "gboxed.h" 1
># 35 "gsignal.c" 2
># 1 "gobject.h" 1
># 36 "gsignal.c" 2
># 1 "genums.h" 1
># 37 "gsignal.c" 2
>
># 1 "gobjectalias.h" 1
># 14 "gobjectalias.h"
>extern __typeof (g_boxed_copy) IA__g_boxed_copy __attribute((visibility("hidden")));
>
>
>extern __typeof (g_boxed_free) IA__g_boxed_free __attribute((visibility("hidden")));
>
>
>extern __typeof (g_boxed_type_register_static) IA__g_boxed_type_register_static __attribute((visibility("hidden")));
>
>
>extern __typeof (g_date_get_type) IA__g_date_get_type __attribute((visibility("hidden"))) __attribute__((__const__));
>
>
>extern __typeof (g_gstring_get_type) IA__g_gstring_get_type __attribute((visibility("hidden"))) __attribute__((__const__));
>
>
>extern __typeof (g_strv_get_type) IA__g_strv_get_type __attribute((visibility("hidden"))) __attribute__((__const__));
>
>
>extern __typeof (g_hash_table_get_type) IA__g_hash_table_get_type __attribute((visibility("hidden"))) __attribute__((__const__));
>
>
>extern __typeof (g_regex_get_type) IA__g_regex_get_type __attribute((visibility("hidden"))) __attribute__((__const__));
>
>
>extern __typeof (g_closure_get_type) IA__g_closure_get_type __attribute((visibility("hidden"))) __attribute__((__const__));
>
>
>extern __typeof (g_value_get_type) IA__g_value_get_type __attribute((visibility("hidden"))) __attribute__((__const__));
>
>
>extern __typeof (g_value_array_get_type) IA__g_value_array_get_type __attribute((visibility("hidden"))) __attribute__((__const__));
>
>
>extern __typeof (g_value_set_boxed) IA__g_value_set_boxed __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_take_boxed) IA__g_value_take_boxed __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_dup_boxed) IA__g_value_dup_boxed __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_get_boxed) IA__g_value_get_boxed __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_set_static_boxed) IA__g_value_set_static_boxed __attribute((visibility("hidden")));
># 71 "gobjectalias.h"
>extern __typeof (g_cclosure_marshal_BOOLEAN__FLAGS) IA__g_cclosure_marshal_BOOLEAN__FLAGS __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_marshal_STRING__OBJECT_POINTER) IA__g_cclosure_marshal_STRING__OBJECT_POINTER __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__BOOLEAN) IA__g_cclosure_marshal_VOID__BOOLEAN __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__BOXED) IA__g_cclosure_marshal_VOID__BOXED __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__CHAR) IA__g_cclosure_marshal_VOID__CHAR __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__DOUBLE) IA__g_cclosure_marshal_VOID__DOUBLE __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__ENUM) IA__g_cclosure_marshal_VOID__ENUM __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__FLAGS) IA__g_cclosure_marshal_VOID__FLAGS __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__FLOAT) IA__g_cclosure_marshal_VOID__FLOAT __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__INT) IA__g_cclosure_marshal_VOID__INT __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__LONG) IA__g_cclosure_marshal_VOID__LONG __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__OBJECT) IA__g_cclosure_marshal_VOID__OBJECT __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__PARAM) IA__g_cclosure_marshal_VOID__PARAM __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__POINTER) IA__g_cclosure_marshal_VOID__POINTER __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__STRING) IA__g_cclosure_marshal_VOID__STRING __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__UCHAR) IA__g_cclosure_marshal_VOID__UCHAR __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__UINT) IA__g_cclosure_marshal_VOID__UINT __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__UINT_POINTER) IA__g_cclosure_marshal_VOID__UINT_POINTER __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__ULONG) IA__g_cclosure_marshal_VOID__ULONG __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__VOID) IA__g_cclosure_marshal_VOID__VOID __attribute((visibility("hidden")));
>
>
>
>
>
>
>extern __typeof (g_cclosure_new) IA__g_cclosure_new __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_new_swap) IA__g_cclosure_new_swap __attribute((visibility("hidden")));
>
>
>extern __typeof (g_closure_add_finalize_notifier) IA__g_closure_add_finalize_notifier __attribute((visibility("hidden")));
>
>
>extern __typeof (g_closure_add_invalidate_notifier) IA__g_closure_add_invalidate_notifier __attribute((visibility("hidden")));
>
>
>extern __typeof (g_closure_add_marshal_guards) IA__g_closure_add_marshal_guards __attribute((visibility("hidden")));
>
>
>extern __typeof (g_closure_invalidate) IA__g_closure_invalidate __attribute((visibility("hidden")));
>
>
>extern __typeof (g_closure_invoke) IA__g_closure_invoke __attribute((visibility("hidden")));
>
>
>extern __typeof (g_closure_new_simple) IA__g_closure_new_simple __attribute((visibility("hidden")));
>
>
>extern __typeof (g_closure_ref) IA__g_closure_ref __attribute((visibility("hidden")));
>
>
>extern __typeof (g_closure_remove_finalize_notifier) IA__g_closure_remove_finalize_notifier __attribute((visibility("hidden")));
>
>
>extern __typeof (g_closure_remove_invalidate_notifier) IA__g_closure_remove_invalidate_notifier __attribute((visibility("hidden")));
>
>
>extern __typeof (g_closure_set_marshal) IA__g_closure_set_marshal __attribute((visibility("hidden")));
>
>
>extern __typeof (g_closure_set_meta_marshal) IA__g_closure_set_meta_marshal __attribute((visibility("hidden")));
>
>
>extern __typeof (g_closure_sink) IA__g_closure_sink __attribute((visibility("hidden")));
>
>
>extern __typeof (g_closure_unref) IA__g_closure_unref __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_type_cclosure_new) IA__g_signal_type_cclosure_new __attribute((visibility("hidden")));
>
>
>
>
>
>
>extern __typeof (g_enum_complete_type_info) IA__g_enum_complete_type_info __attribute((visibility("hidden")));
>
>
>extern __typeof (g_enum_get_value) IA__g_enum_get_value __attribute((visibility("hidden")));
>
>
>extern __typeof (g_enum_get_value_by_name) IA__g_enum_get_value_by_name __attribute((visibility("hidden")));
>
>
>extern __typeof (g_enum_get_value_by_nick) IA__g_enum_get_value_by_nick __attribute((visibility("hidden")));
>
>
>extern __typeof (g_enum_register_static) IA__g_enum_register_static __attribute((visibility("hidden")));
>
>
>extern __typeof (g_flags_complete_type_info) IA__g_flags_complete_type_info __attribute((visibility("hidden")));
>
>
>extern __typeof (g_flags_get_first_value) IA__g_flags_get_first_value __attribute((visibility("hidden")));
>
>
>extern __typeof (g_flags_get_value_by_name) IA__g_flags_get_value_by_name __attribute((visibility("hidden")));
>
>
>extern __typeof (g_flags_get_value_by_nick) IA__g_flags_get_value_by_nick __attribute((visibility("hidden")));
>
>
>extern __typeof (g_flags_register_static) IA__g_flags_register_static __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_set_enum) IA__g_value_set_enum __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_set_flags) IA__g_value_set_flags __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_get_enum) IA__g_value_get_enum __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_get_flags) IA__g_value_get_flags __attribute((visibility("hidden")));
>
>
>
>
>
>
>extern __typeof (g_io_channel_get_type) IA__g_io_channel_get_type __attribute((visibility("hidden")));
>
>
>extern __typeof (g_io_condition_get_type) IA__g_io_condition_get_type __attribute((visibility("hidden")));
>
>
>extern __typeof (g_source_set_closure) IA__g_source_set_closure __attribute((visibility("hidden")));
>
>
>
>
>
>
>extern __typeof (g_cclosure_new_object) IA__g_cclosure_new_object __attribute((visibility("hidden")));
>
>
>extern __typeof (g_cclosure_new_object_swap) IA__g_cclosure_new_object_swap __attribute((visibility("hidden")));
>
>
>extern __typeof (g_closure_new_object) IA__g_closure_new_object __attribute((visibility("hidden")));
>
>
>extern __typeof (g_initially_unowned_get_type) IA__g_initially_unowned_get_type __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_add_weak_pointer) IA__g_object_add_weak_pointer __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_class_find_property) IA__g_object_class_find_property __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_class_install_property) IA__g_object_class_install_property __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_class_list_properties) IA__g_object_class_list_properties __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_class_override_property) IA__g_object_class_override_property __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_connect) IA__g_object_connect __attribute((visibility("hidden"))) __attribute__((__sentinel__));
>
>
>extern __typeof (g_object_disconnect) IA__g_object_disconnect __attribute((visibility("hidden"))) __attribute__((__sentinel__));
>
>
>extern __typeof (g_object_freeze_notify) IA__g_object_freeze_notify __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_get) IA__g_object_get __attribute((visibility("hidden"))) __attribute__((__sentinel__));
>
>
>extern __typeof (g_object_get_data) IA__g_object_get_data __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_get_property) IA__g_object_get_property __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_get_qdata) IA__g_object_get_qdata __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_get_valist) IA__g_object_get_valist __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_interface_find_property) IA__g_object_interface_find_property __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_interface_install_property) IA__g_object_interface_install_property __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_interface_list_properties) IA__g_object_interface_list_properties __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_new) IA__g_object_new __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_newv) IA__g_object_newv __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_new_valist) IA__g_object_new_valist __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_notify) IA__g_object_notify __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_is_floating) IA__g_object_is_floating __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_ref_sink) IA__g_object_ref_sink __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_force_floating) IA__g_object_force_floating __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_ref) IA__g_object_ref __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_unref) IA__g_object_unref __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_remove_weak_pointer) IA__g_object_remove_weak_pointer __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_run_dispose) IA__g_object_run_dispose __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_set) IA__g_object_set __attribute((visibility("hidden"))) __attribute__((__sentinel__));
>
>
>extern __typeof (g_object_set_data) IA__g_object_set_data __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_set_data_full) IA__g_object_set_data_full __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_set_property) IA__g_object_set_property __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_set_qdata) IA__g_object_set_qdata __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_set_qdata_full) IA__g_object_set_qdata_full __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_set_valist) IA__g_object_set_valist __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_steal_data) IA__g_object_steal_data __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_steal_qdata) IA__g_object_steal_qdata __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_thaw_notify) IA__g_object_thaw_notify __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_watch_closure) IA__g_object_watch_closure __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_weak_ref) IA__g_object_weak_ref __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_weak_unref) IA__g_object_weak_unref __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_add_toggle_ref) IA__g_object_add_toggle_ref __attribute((visibility("hidden")));
>
>
>extern __typeof (g_object_remove_toggle_ref) IA__g_object_remove_toggle_ref __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_get_object) IA__g_value_get_object __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_set_object) IA__g_value_set_object __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_dup_object) IA__g_value_dup_object __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_take_object) IA__g_value_take_object __attribute((visibility("hidden")));
># 404 "gobjectalias.h"
>extern __typeof (g_signal_connect_object) IA__g_signal_connect_object __attribute((visibility("hidden")));
>
>
>
>
>
>
>extern __typeof (g_param_spec_boolean) IA__g_param_spec_boolean __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_boxed) IA__g_param_spec_boxed __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_char) IA__g_param_spec_char __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_double) IA__g_param_spec_double __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_enum) IA__g_param_spec_enum __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_flags) IA__g_param_spec_flags __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_float) IA__g_param_spec_float __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_int) IA__g_param_spec_int __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_int64) IA__g_param_spec_int64 __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_long) IA__g_param_spec_long __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_object) IA__g_param_spec_object __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_override) IA__g_param_spec_override __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_gtype) IA__g_param_spec_gtype __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_param) IA__g_param_spec_param __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_pointer) IA__g_param_spec_pointer __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_string) IA__g_param_spec_string __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_uchar) IA__g_param_spec_uchar __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_uint) IA__g_param_spec_uint __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_uint64) IA__g_param_spec_uint64 __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_ulong) IA__g_param_spec_ulong __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_unichar) IA__g_param_spec_unichar __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_value_array) IA__g_param_spec_value_array __attribute((visibility("hidden")));
>
>
>
>
>
>
>extern __typeof (g_param_spec_get_blurb) IA__g_param_spec_get_blurb __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_get_name) IA__g_param_spec_get_name __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_get_nick) IA__g_param_spec_get_nick __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_get_redirect_target) IA__g_param_spec_get_redirect_target __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_internal) IA__g_param_spec_internal __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_type_register_static) IA__g_param_type_register_static __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_ref) IA__g_param_spec_ref __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_ref_sink) IA__g_param_spec_ref_sink __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_unref) IA__g_param_spec_unref __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_sink) IA__g_param_spec_sink __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_steal_qdata) IA__g_param_spec_steal_qdata __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_set_qdata) IA__g_param_spec_set_qdata __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_set_qdata_full) IA__g_param_spec_set_qdata_full __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_get_qdata) IA__g_param_spec_get_qdata __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_value_convert) IA__g_param_value_convert __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_value_defaults) IA__g_param_value_defaults __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_values_cmp) IA__g_param_values_cmp __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_value_set_default) IA__g_param_value_set_default __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_value_validate) IA__g_param_value_validate __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_pool_insert) IA__g_param_spec_pool_insert __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_pool_list) IA__g_param_spec_pool_list __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_pool_list_owned) IA__g_param_spec_pool_list_owned __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_pool_lookup) IA__g_param_spec_pool_lookup __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_pool_new) IA__g_param_spec_pool_new __attribute((visibility("hidden")));
>
>
>extern __typeof (g_param_spec_pool_remove) IA__g_param_spec_pool_remove __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_get_param) IA__g_value_get_param __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_set_param) IA__g_value_set_param __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_dup_param) IA__g_value_dup_param __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_take_param) IA__g_value_take_param __attribute((visibility("hidden")));
># 577 "gobjectalias.h"
>extern __typeof (g_pointer_type_register_static) IA__g_pointer_type_register_static __attribute((visibility("hidden")));
>
>
>extern __typeof (g_strdup_value_contents) IA__g_strdup_value_contents __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_set_boolean) IA__g_value_set_boolean __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_set_char) IA__g_value_set_char __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_set_double) IA__g_value_set_double __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_set_float) IA__g_value_set_float __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_set_int) IA__g_value_set_int __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_set_int64) IA__g_value_set_int64 __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_set_long) IA__g_value_set_long __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_set_pointer) IA__g_value_set_pointer __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_set_static_string) IA__g_value_set_static_string __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_set_string) IA__g_value_set_string __attribute((visibility("hidden")));
>
>
>
>
>
>
>
>extern __typeof (g_value_set_uchar) IA__g_value_set_uchar __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_set_uint) IA__g_value_set_uint __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_set_uint64) IA__g_value_set_uint64 __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_set_ulong) IA__g_value_set_ulong __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_dup_string) IA__g_value_dup_string __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_get_boolean) IA__g_value_get_boolean __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_get_char) IA__g_value_get_char __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_get_double) IA__g_value_get_double __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_get_float) IA__g_value_get_float __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_get_int) IA__g_value_get_int __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_get_int64) IA__g_value_get_int64 __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_get_long) IA__g_value_get_long __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_get_pointer) IA__g_value_get_pointer __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_get_string) IA__g_value_get_string __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_get_uchar) IA__g_value_get_uchar __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_get_uint) IA__g_value_get_uint __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_get_uint64) IA__g_value_get_uint64 __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_get_ulong) IA__g_value_get_ulong __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_take_string) IA__g_value_take_string __attribute((visibility("hidden")));
>
>
>extern __typeof (g_gtype_get_type) IA__g_gtype_get_type __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_set_gtype) IA__g_value_set_gtype __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_get_gtype) IA__g_value_get_gtype __attribute((visibility("hidden")));
>
>
>
>
>
>
>extern __typeof (g_signal_accumulator_true_handled) IA__g_signal_accumulator_true_handled __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_add_emission_hook) IA__g_signal_add_emission_hook __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_chain_from_overridden) IA__g_signal_chain_from_overridden __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_connect_closure) IA__g_signal_connect_closure __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_connect_closure_by_id) IA__g_signal_connect_closure_by_id __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_connect_data) IA__g_signal_connect_data __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_emit) IA__g_signal_emit __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_emit_by_name) IA__g_signal_emit_by_name __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_emitv) IA__g_signal_emitv __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_emit_valist) IA__g_signal_emit_valist __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_get_invocation_hint) IA__g_signal_get_invocation_hint __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_handler_block) IA__g_signal_handler_block __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_handler_disconnect) IA__g_signal_handler_disconnect __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_handler_find) IA__g_signal_handler_find __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_handler_is_connected) IA__g_signal_handler_is_connected __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_handlers_block_matched) IA__g_signal_handlers_block_matched __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_handlers_destroy) IA__g_signal_handlers_destroy __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_handlers_disconnect_matched) IA__g_signal_handlers_disconnect_matched __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_handlers_unblock_matched) IA__g_signal_handlers_unblock_matched __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_handler_unblock) IA__g_signal_handler_unblock __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_has_handler_pending) IA__g_signal_has_handler_pending __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_list_ids) IA__g_signal_list_ids __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_lookup) IA__g_signal_lookup __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_name) IA__g_signal_name __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_new) IA__g_signal_new __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_newv) IA__g_signal_newv __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_new_valist) IA__g_signal_new_valist __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_override_class_closure) IA__g_signal_override_class_closure __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_parse_name) IA__g_signal_parse_name __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_query) IA__g_signal_query __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_remove_emission_hook) IA__g_signal_remove_emission_hook __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_stop_emission) IA__g_signal_stop_emission __attribute((visibility("hidden")));
>
>
>extern __typeof (g_signal_stop_emission_by_name) IA__g_signal_stop_emission_by_name __attribute((visibility("hidden")));
>
>
>
>
>
>
>extern __typeof (g_type_add_class_cache_func) IA__g_type_add_class_cache_func __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_add_interface_check) IA__g_type_add_interface_check __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_add_interface_dynamic) IA__g_type_add_interface_dynamic __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_add_interface_static) IA__g_type_add_interface_static __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_check_class_cast) IA__g_type_check_class_cast __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_check_class_is_a) IA__g_type_check_class_is_a __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_check_instance) IA__g_type_check_instance __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_check_instance_cast) IA__g_type_check_instance_cast __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_check_instance_is_a) IA__g_type_check_instance_is_a __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_check_is_value_type) IA__g_type_check_is_value_type __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_check_value) IA__g_type_check_value __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_check_value_holds) IA__g_type_check_value_holds __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_children) IA__g_type_children __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_class_add_private) IA__g_type_class_add_private __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_class_peek) IA__g_type_class_peek __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_class_peek_parent) IA__g_type_class_peek_parent __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_class_peek_static) IA__g_type_class_peek_static __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_class_ref) IA__g_type_class_ref __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_class_unref) IA__g_type_class_unref __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_class_unref_uncached) IA__g_type_class_unref_uncached __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_create_instance) IA__g_type_create_instance __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_default_interface_peek) IA__g_type_default_interface_peek __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_default_interface_ref) IA__g_type_default_interface_ref __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_default_interface_unref) IA__g_type_default_interface_unref __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_depth) IA__g_type_depth __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_free_instance) IA__g_type_free_instance __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_from_name) IA__g_type_from_name __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_fundamental) IA__g_type_fundamental __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_fundamental_next) IA__g_type_fundamental_next __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_get_plugin) IA__g_type_get_plugin __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_get_qdata) IA__g_type_get_qdata __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_init) IA__g_type_init __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_init_with_debug_flags) IA__g_type_init_with_debug_flags __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_instance_get_private) IA__g_type_instance_get_private __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_interface_add_prerequisite) IA__g_type_interface_add_prerequisite __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_interface_get_plugin) IA__g_type_interface_get_plugin __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_interface_peek) IA__g_type_interface_peek __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_interface_peek_parent) IA__g_type_interface_peek_parent __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_interface_prerequisites) IA__g_type_interface_prerequisites __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_interfaces) IA__g_type_interfaces __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_is_a) IA__g_type_is_a __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_name) IA__g_type_name __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_name_from_class) IA__g_type_name_from_class __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_name_from_instance) IA__g_type_name_from_instance __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_next_base) IA__g_type_next_base __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_parent) IA__g_type_parent __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_qname) IA__g_type_qname __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_query) IA__g_type_query __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_register_dynamic) IA__g_type_register_dynamic __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_register_fundamental) IA__g_type_register_fundamental __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_register_static) IA__g_type_register_static __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_register_static_simple) IA__g_type_register_static_simple __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_remove_class_cache_func) IA__g_type_remove_class_cache_func __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_remove_interface_check) IA__g_type_remove_interface_check __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_set_qdata) IA__g_type_set_qdata __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_test_flags) IA__g_type_test_flags __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_value_table_peek) IA__g_type_value_table_peek __attribute((visibility("hidden")));
>
>
>
>
>
>
>extern __typeof (g_type_module_add_interface) IA__g_type_module_add_interface __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_module_get_type) IA__g_type_module_get_type __attribute((visibility("hidden"))) __attribute__((__const__));
>
>
>extern __typeof (g_type_module_register_enum) IA__g_type_module_register_enum __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_module_register_flags) IA__g_type_module_register_flags __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_module_register_type) IA__g_type_module_register_type __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_module_set_name) IA__g_type_module_set_name __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_module_unuse) IA__g_type_module_unuse __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_module_use) IA__g_type_module_use __attribute((visibility("hidden")));
>
>
>
>
>
>
>extern __typeof (g_value_array_append) IA__g_value_array_append __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_array_copy) IA__g_value_array_copy __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_array_free) IA__g_value_array_free __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_array_get_nth) IA__g_value_array_get_nth __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_array_insert) IA__g_value_array_insert __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_array_new) IA__g_value_array_new __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_array_prepend) IA__g_value_array_prepend __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_array_remove) IA__g_value_array_remove __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_array_sort) IA__g_value_array_sort __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_array_sort_with_data) IA__g_value_array_sort_with_data __attribute((visibility("hidden")));
>
>
>
>
>
>
>extern __typeof (g_type_plugin_complete_interface_info) IA__g_type_plugin_complete_interface_info __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_plugin_complete_type_info) IA__g_type_plugin_complete_type_info __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_plugin_get_type) IA__g_type_plugin_get_type __attribute((visibility("hidden"))) __attribute__((__const__));
>
>
>extern __typeof (g_type_plugin_unuse) IA__g_type_plugin_unuse __attribute((visibility("hidden")));
>
>
>extern __typeof (g_type_plugin_use) IA__g_type_plugin_use __attribute((visibility("hidden")));
>
>
>
>
>
>
>extern __typeof (g_value_copy) IA__g_value_copy __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_fits_pointer) IA__g_value_fits_pointer __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_init) IA__g_value_init __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_peek_pointer) IA__g_value_peek_pointer __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_register_transform_func) IA__g_value_register_transform_func __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_reset) IA__g_value_reset __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_transform) IA__g_value_transform __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_type_compatible) IA__g_value_type_compatible __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_type_transformable) IA__g_value_type_transformable __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_unset) IA__g_value_unset __attribute((visibility("hidden")));
>
>
>extern __typeof (g_value_set_instance) IA__g_value_set_instance __attribute((visibility("hidden")));
># 39 "gsignal.c" 2
>
>
># 1 "/usr/include/signal.h" 1 3 4
># 31 "/usr/include/signal.h" 3 4
>
>
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 24 "/usr/include/bits/sigset.h" 3 4
>typedef int __sig_atomic_t;
>
>
>
>
>typedef struct
>  {
>    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
>  } __sigset_t;
># 104 "/usr/include/bits/sigset.h" 3 4
>extern int __sigismember (__const __sigset_t *, int);
>extern int __sigaddset (__sigset_t *, int);
>extern int __sigdelset (__sigset_t *, int);
># 118 "/usr/include/bits/sigset.h" 3 4
>extern __inline int __sigismember (__const __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return (__set->__val[__word] & __mask) ? 1 : 0; }
>extern __inline int __sigaddset ( __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return ((__set->__val[__word] |= __mask), 0); }
>extern __inline int __sigdelset ( __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return ((__set->__val[__word] &= ~__mask), 0); }
># 34 "/usr/include/signal.h" 2 3 4
>
>
>
>
>
>
>
>typedef __sig_atomic_t sig_atomic_t;
>
>
>
>
>
>
>
>
>typedef __sigset_t sigset_t;
>
>
>
>
>
>
>
># 1 "/usr/include/bits/signum.h" 1 3 4
># 59 "/usr/include/signal.h" 2 3 4
># 68 "/usr/include/signal.h" 3 4
>typedef __uid_t uid_t;
>
>
>
>
>
>
>typedef void (*__sighandler_t) (int);
>
>
>
>
>extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
>     __attribute__ ((__nothrow__));
># 90 "/usr/include/signal.h" 3 4
>
>
>extern __sighandler_t signal (int __sig, __sighandler_t __handler)
>     __attribute__ ((__nothrow__));
># 104 "/usr/include/signal.h" 3 4
>
># 117 "/usr/include/signal.h" 3 4
>extern int kill (__pid_t __pid, int __sig) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern int killpg (__pid_t __pgrp, int __sig) __attribute__ ((__nothrow__));
>
>
>
>
>extern int raise (int __sig) __attribute__ ((__nothrow__));
>
>
>
>
>extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
>     __attribute__ ((__nothrow__));
>extern int gsignal (int __sig) __attribute__ ((__nothrow__));
>
>
>
>
>extern void psignal (int __sig, __const char *__s);
># 153 "/usr/include/signal.h" 3 4
>extern int __sigpause (int __sig_or_mask, int __is_sig);
># 181 "/usr/include/signal.h" 3 4
>extern int sigblock (int __mask) __attribute__ ((__nothrow__)) __attribute__ ((__deprecated__));
>
>
>extern int sigsetmask (int __mask) __attribute__ ((__nothrow__)) __attribute__ ((__deprecated__));
>
>
>extern int siggetmask (void) __attribute__ ((__nothrow__)) __attribute__ ((__deprecated__));
># 201 "/usr/include/signal.h" 3 4
>typedef __sighandler_t sig_t;
># 212 "/usr/include/signal.h" 3 4
># 1 "/usr/include/bits/siginfo.h" 1 3 4
># 25 "/usr/include/bits/siginfo.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 26 "/usr/include/bits/siginfo.h" 2 3 4
>
>
>
>
>
>
>
>typedef union sigval
>  {
>    int sival_int;
>    void *sival_ptr;
>  } sigval_t;
># 51 "/usr/include/bits/siginfo.h" 3 4
>typedef struct siginfo
>  {
>    int si_signo;
>    int si_errno;
>
>    int si_code;
>
>    union
>      {
> int _pad[((128 / sizeof (int)) - 3)];
>
>
> struct
>   {
>     __pid_t si_pid;
>     __uid_t si_uid;
>   } _kill;
>
>
> struct
>   {
>     int si_tid;
>     int si_overrun;
>     sigval_t si_sigval;
>   } _timer;
>
>
> struct
>   {
>     __pid_t si_pid;
>     __uid_t si_uid;
>     sigval_t si_sigval;
>   } _rt;
>
>
> struct
>   {
>     __pid_t si_pid;
>     __uid_t si_uid;
>     int si_status;
>     __clock_t si_utime;
>     __clock_t si_stime;
>   } _sigchld;
>
>
> struct
>   {
>     void *si_addr;
>   } _sigfault;
>
>
> struct
>   {
>     long int si_band;
>     int si_fd;
>   } _sigpoll;
>      } _sifields;
>  } siginfo_t;
># 129 "/usr/include/bits/siginfo.h" 3 4
>enum
>{
>  SI_ASYNCNL = -60,
>
>  SI_TKILL = -6,
>
>  SI_SIGIO,
>
>  SI_ASYNCIO,
>
>  SI_MESGQ,
>
>  SI_TIMER,
>
>  SI_QUEUE,
>
>  SI_USER,
>
>  SI_KERNEL = 0x80
>
>};
>
>
>
>enum
>{
>  ILL_ILLOPC = 1,
>
>  ILL_ILLOPN,
>
>  ILL_ILLADR,
>
>  ILL_ILLTRP,
>
>  ILL_PRVOPC,
>
>  ILL_PRVREG,
>
>  ILL_COPROC,
>
>  ILL_BADSTK
>
>};
>
>
>enum
>{
>  FPE_INTDIV = 1,
>
>  FPE_INTOVF,
>
>  FPE_FLTDIV,
>
>  FPE_FLTOVF,
>
>  FPE_FLTUND,
>
>  FPE_FLTRES,
>
>  FPE_FLTINV,
>
>  FPE_FLTSUB
>
>};
>
>
>enum
>{
>  SEGV_MAPERR = 1,
>
>  SEGV_ACCERR
>
>};
>
>
>enum
>{
>  BUS_ADRALN = 1,
>
>  BUS_ADRERR,
>
>  BUS_OBJERR
>
>};
>
>
>enum
>{
>  TRAP_BRKPT = 1,
>
>  TRAP_TRACE
>
>};
>
>
>enum
>{
>  CLD_EXITED = 1,
>
>  CLD_KILLED,
>
>  CLD_DUMPED,
>
>  CLD_TRAPPED,
>
>  CLD_STOPPED,
>
>  CLD_CONTINUED
>
>};
>
>
>enum
>{
>  POLL_IN = 1,
>
>  POLL_OUT,
>
>  POLL_MSG,
>
>  POLL_ERR,
>
>  POLL_PRI,
>
>  POLL_HUP
>
>};
># 273 "/usr/include/bits/siginfo.h" 3 4
>typedef struct sigevent
>  {
>    sigval_t sigev_value;
>    int sigev_signo;
>    int sigev_notify;
>
>    union
>      {
> int _pad[((64 / sizeof (int)) - 3)];
>
>
>
> __pid_t _tid;
>
> struct
>   {
>     void (*_function) (sigval_t);
>     void *_attribute;
>   } _sigev_thread;
>      } _sigev_un;
>  } sigevent_t;
>
>
>
>
>
>
>enum
>{
>  SIGEV_SIGNAL = 0,
>
>  SIGEV_NONE,
>
>  SIGEV_THREAD,
>
>
>  SIGEV_THREAD_ID = 4
>
>};
># 213 "/usr/include/signal.h" 2 3 4
>
>
>
>extern int sigemptyset (sigset_t *__set) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigfillset (sigset_t *__set) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigaddset (sigset_t *__set, int __signo) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigdelset (sigset_t *__set, int __signo) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigismember (__const sigset_t *__set, int __signo)
>     __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
># 246 "/usr/include/signal.h" 3 4
># 1 "/usr/include/bits/sigaction.h" 1 3 4
># 25 "/usr/include/bits/sigaction.h" 3 4
>struct sigaction
>  {
>
>
>    union
>      {
>
> __sighandler_t sa_handler;
>
> void (*sa_sigaction) (int, siginfo_t *, void *);
>      }
>    __sigaction_handler;
>
>
>
>
>
>
>
>    __sigset_t sa_mask;
>
>
>    int sa_flags;
>
>
>    void (*sa_restorer) (void);
>  };
># 247 "/usr/include/signal.h" 2 3 4
>
>
>extern int sigprocmask (int __how, __const sigset_t *__restrict __set,
>   sigset_t *__restrict __oset) __attribute__ ((__nothrow__));
>
>
>
>
>
>
>extern int sigsuspend (__const sigset_t *__set) __attribute__ ((__nonnull__ (1)));
>
>
>extern int sigaction (int __sig, __const struct sigaction *__restrict __act,
>        struct sigaction *__restrict __oact) __attribute__ ((__nothrow__));
>
>
>extern int sigpending (sigset_t *__set) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int sigwait (__const sigset_t *__restrict __set, int *__restrict __sig)
>     __attribute__ ((__nonnull__ (1, 2)));
>
>
>
>
>
>
>extern int sigwaitinfo (__const sigset_t *__restrict __set,
>   siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));
>
>
>
>
>
>
>extern int sigtimedwait (__const sigset_t *__restrict __set,
>    siginfo_t *__restrict __info,
>    __const struct timespec *__restrict __timeout)
>     __attribute__ ((__nonnull__ (1)));
>
>
>
>extern int sigqueue (__pid_t __pid, int __sig, __const union sigval __val)
>     __attribute__ ((__nothrow__));
># 304 "/usr/include/signal.h" 3 4
>extern __const char *__const _sys_siglist[65];
>extern __const char *__const sys_siglist[65];
>
>
>struct sigvec
>  {
>    __sighandler_t sv_handler;
>    int sv_mask;
>
>    int sv_flags;
>
>  };
># 328 "/usr/include/signal.h" 3 4
>extern int sigvec (int __sig, __const struct sigvec *__vec,
>     struct sigvec *__ovec) __attribute__ ((__nothrow__));
>
>
>
># 1 "/usr/include/bits/sigcontext.h" 1 3 4
># 28 "/usr/include/bits/sigcontext.h" 3 4
># 1 "/usr/include/asm/sigcontext.h" 1 3 4
># 10 "/usr/include/asm/sigcontext.h" 3 4
># 1 "/usr/include/asm/ptrace.h" 1 3 4
># 29 "/usr/include/asm/ptrace.h" 3 4
>struct pt_regs {
> unsigned long gpr[32];
> unsigned long nip;
> unsigned long msr;
> unsigned long orig_gpr3;
> unsigned long ctr;
> unsigned long link;
> unsigned long xer;
> unsigned long ccr;
>
>
>
> unsigned long mq;
>
>
> unsigned long trap;
>
>
> unsigned long dar;
> unsigned long dsisr;
> unsigned long result;
>};
># 11 "/usr/include/asm/sigcontext.h" 2 3 4
>
>
>
>
>struct sigcontext {
> unsigned long _unused[4];
> int signal;
>
>
>
> unsigned long handler;
> unsigned long oldmask;
> struct pt_regs *regs;
># 49 "/usr/include/asm/sigcontext.h" 3 4
>};
># 29 "/usr/include/bits/sigcontext.h" 2 3 4
># 334 "/usr/include/signal.h" 2 3 4
>
>
>extern int sigreturn (struct sigcontext *__scp) __attribute__ ((__nothrow__));
>
>
>
>
>
>
># 1 "/usr/lib/gcc/ppc64-redhat-linux/4.3.0/include/stddef.h" 1 3 4
># 344 "/usr/include/signal.h" 2 3 4
>
>
>
>
>extern int siginterrupt (int __sig, int __interrupt) __attribute__ ((__nothrow__));
>
># 1 "/usr/include/bits/sigstack.h" 1 3 4
># 26 "/usr/include/bits/sigstack.h" 3 4
>struct sigstack
>  {
>    void *ss_sp;
>    int ss_onstack;
>  };
>
>
>
>enum
>{
>  SS_ONSTACK = 1,
>
>  SS_DISABLE
>
>};
># 50 "/usr/include/bits/sigstack.h" 3 4
>typedef struct sigaltstack
>  {
>    void *ss_sp;
>    int ss_flags;
>    size_t ss_size;
>  } stack_t;
># 351 "/usr/include/signal.h" 2 3 4
># 359 "/usr/include/signal.h" 3 4
>extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
>     __attribute__ ((__nothrow__)) __attribute__ ((__deprecated__));
>
>
>
>extern int sigaltstack (__const struct sigaltstack *__restrict __ss,
>   struct sigaltstack *__restrict __oss) __attribute__ ((__nothrow__));
># 388 "/usr/include/signal.h" 3 4
># 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
># 24 "/usr/include/bits/pthreadtypes.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 25 "/usr/include/bits/pthreadtypes.h" 2 3 4
># 51 "/usr/include/bits/pthreadtypes.h" 3 4
>typedef unsigned long int pthread_t;
>
>
>typedef union
>{
>  char __size[36];
>  long int __align;
>} pthread_attr_t;
># 68 "/usr/include/bits/pthreadtypes.h" 3 4
>typedef struct __pthread_internal_slist
>{
>  struct __pthread_internal_slist *__next;
>} __pthread_slist_t;
>
>
>
>
>
>typedef union
>{
>  struct __pthread_mutex_s
>  {
>    int __lock;
>    unsigned int __count;
>    int __owner;
>
>
>
>
>
>    int __kind;
>
>
>
>
>
>    unsigned int __nusers;
>    __extension__ union
>    {
>      int __spins;
>      __pthread_slist_t __list;
>    };
>
>  } __data;
>  char __size[24];
>  long int __align;
>} pthread_mutex_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_mutexattr_t;
>
>
>
>
>typedef union
>{
>  struct
>  {
>    int __lock;
>    unsigned int __futex;
>    __extension__ unsigned long long int __total_seq;
>    __extension__ unsigned long long int __wakeup_seq;
>    __extension__ unsigned long long int __woken_seq;
>    void *__mutex;
>    unsigned int __nwaiters;
>    unsigned int __broadcast_seq;
>  } __data;
>  char __size[48];
>  __extension__ long long int __align;
>} pthread_cond_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_condattr_t;
>
>
>
>typedef unsigned int pthread_key_t;
>
>
>
>typedef int pthread_once_t;
>
>
>
>
>
>typedef union
>{
># 171 "/usr/include/bits/pthreadtypes.h" 3 4
>  struct
>  {
>    int __lock;
>    unsigned int __nr_readers;
>    unsigned int __readers_wakeup;
>    unsigned int __writer_wakeup;
>    unsigned int __nr_readers_queued;
>    unsigned int __nr_writers_queued;
>    unsigned char __pad1;
>    unsigned char __pad2;
>    unsigned char __shared;
>
>
>    unsigned char __flags;
>    int __writer;
>  } __data;
>
>  char __size[32];
>  long int __align;
>} pthread_rwlock_t;
>
>typedef union
>{
>  char __size[8];
>  long int __align;
>} pthread_rwlockattr_t;
>
>
>
>
>
>typedef volatile int pthread_spinlock_t;
>
>
>
>
>typedef union
>{
>  char __size[20];
>  long int __align;
>} pthread_barrier_t;
>
>typedef union
>{
>  char __size[4];
>  int __align;
>} pthread_barrierattr_t;
># 389 "/usr/include/signal.h" 2 3 4
># 1 "/usr/include/bits/sigthread.h" 1 3 4
># 31 "/usr/include/bits/sigthread.h" 3 4
>extern int pthread_sigmask (int __how,
>       __const __sigset_t *__restrict __newmask,
>       __sigset_t *__restrict __oldmask)__attribute__ ((__nothrow__));
>
>
>extern int pthread_kill (pthread_t __threadid, int __signo) __attribute__ ((__nothrow__));
># 390 "/usr/include/signal.h" 2 3 4
>
>
>
>
>
>
>extern int __libc_current_sigrtmin (void) __attribute__ ((__nothrow__));
>
>extern int __libc_current_sigrtmax (void) __attribute__ ((__nothrow__));
>
>
>
>
># 42 "gsignal.c" 2
># 57 "gsignal.c"
>typedef struct _SignalNode SignalNode;
>typedef struct _SignalKey SignalKey;
>typedef struct _Emission Emission;
>typedef struct _Handler Handler;
>typedef struct _HandlerList HandlerList;
>typedef struct _HandlerMatch HandlerMatch;
>typedef enum
>{
>  EMISSION_STOP,
>  EMISSION_RUN,
>  EMISSION_HOOK,
>  EMISSION_RESTART
>} EmissionState;
>
>
>
>static inline guint signal_id_lookup (GQuark quark,
>        GType itype);
>static void signal_destroy_R (SignalNode *signal_node);
>static inline HandlerList* handler_list_ensure (guint signal_id,
>        gpointer instance);
>static inline HandlerList* handler_list_lookup (guint signal_id,
>        gpointer instance);
>static inline Handler* handler_new (gboolean after);
>static void handler_insert (guint signal_id,
>        gpointer instance,
>        Handler *handler);
>static Handler* handler_lookup (gpointer instance,
>        gulong handler_id,
>        guint *signal_id_p);
>static inline HandlerMatch* handler_match_prepend (HandlerMatch *list,
>        Handler *handler,
>        guint signal_id);
>static inline HandlerMatch* handler_match_free1_R (HandlerMatch *node,
>        gpointer instance);
>static HandlerMatch* handlers_find (gpointer instance,
>        GSignalMatchType mask,
>        guint signal_id,
>        GQuark detail,
>        GClosure *closure,
>        gpointer func,
>        gpointer data,
>        gboolean one_and_only);
>static inline void handler_ref (Handler *handler);
>static inline void handler_unref_R (guint signal_id,
>        gpointer instance,
>        Handler *handler);
>static gint handler_lists_cmp (gconstpointer node1,
>        gconstpointer node2);
>static inline void emission_push (Emission **emission_list_p,
>        Emission *emission);
>static inline void emission_pop (Emission **emission_list_p,
>        Emission *emission);
>static inline Emission* emission_find (Emission *emission_list,
>        guint signal_id,
>        GQuark detail,
>        gpointer instance);
>static gint class_closures_cmp (gconstpointer node1,
>        gconstpointer node2);
>static gint signal_key_cmp (gconstpointer node1,
>        gconstpointer node2);
>static gboolean signal_emit_unlocked_R (SignalNode *node,
>        GQuark detail,
>        gpointer instance,
>        GValue *return_value,
>        const GValue *instance_and_params);
>static const gchar * type_debug_name (GType type);
>
>
>
>typedef struct
>{
>  GSignalAccumulator func;
>  gpointer data;
>} SignalAccumulator;
>typedef struct
>{
>  GHook hook;
>  GQuark detail;
>} SignalHook;
>
>
>struct _SignalNode
>{
>
>  guint signal_id;
>  GType itype;
>  const gchar *name;
>  guint destroyed : 1;
>
>
>  guint test_class_offset : 12;
>  guint flags : 8;
>  guint n_params : 8;
>  GType *param_types;
>  GType return_type;
>  GBSearchArray *class_closure_bsa;
>  SignalAccumulator *accumulator;
>  GSignalCMarshaller c_marshaller;
>  GHookList *emission_hooks;
>};
>
>
>
>struct _SignalKey
>{
>  GType itype;
>  GQuark quark;
>  guint signal_id;
>};
>
>struct _Emission
>{
>  Emission *next;
>  gpointer instance;
>  GSignalInvocationHint ihint;
>  EmissionState state;
>  GType chain_type;
>};
>
>struct _HandlerList
>{
>  guint signal_id;
>  Handler *handlers;
>  Handler *tail_before;
>  Handler *tail_after;
>};
>
>struct _Handler
>{
>  gulong sequential_number;
>  Handler *next;
>  Handler *prev;
>  GQuark detail;
>  guint ref_count;
>  guint block_count : 16;
>
>  guint after : 1;
>  GClosure *closure;
>};
>struct _HandlerMatch
>{
>  Handler *handler;
>  HandlerMatch *next;
>  guint signal_id;
>};
>
>typedef struct
>{
>  GType instance_type;
>  GClosure *closure;
>} ClassClosure;
>
>
>
>static GBSearchArray *g_signal_key_bsa = ((void *)0);
>static const GBSearchConfig g_signal_key_bconfig = {
>  sizeof (SignalKey),
>  signal_key_cmp,
>  G_BSEARCH_ARRAY_ALIGN_POWER2,
>};
>static GBSearchConfig g_signal_hlbsa_bconfig = {
>  sizeof (HandlerList),
>  handler_lists_cmp,
>  0,
>};
>static GBSearchConfig g_class_closure_bconfig = {
>  sizeof (ClassClosure),
>  class_closures_cmp,
>  0,
>};
>static GHashTable *g_handler_list_bsa_ht = ((void *)0);
>static Emission *g_recursive_emissions = ((void *)0);
>static Emission *g_restart_emissions = ((void *)0);
>static gulong g_handler_sequential_number = 1;
>static GStaticMutex g__g_signal_mutex_lock = { ((void *)0), { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0} } };
>
>
>
>
>
>static guint g_n_signal_nodes = 0;
>static SignalNode **g_signal_nodes = ((void *)0);
>
>static inline SignalNode*
>LOOKUP_SIGNAL_NODE (register guint signal_id)
>{
>  if (signal_id < g_n_signal_nodes)
>    return g_signal_nodes[signal_id];
>  else
>    return ((void *)0);
>}
>
>
>
>static inline guint
>signal_id_lookup (GQuark quark,
>    GType itype)
>{
>  GType *ifaces, type = itype;
>  SignalKey key;
>  guint n_ifaces;
>
>  key.quark = quark;
>
>
>  do
>    {
>      SignalKey *signal_key;
>
>      key.itype = type;
>      signal_key = g_bsearch_array_lookup_fuzzy ((g_signal_key_bsa), (&g_signal_key_bconfig), (&key), 0);
>
>      if (signal_key)
> return signal_key->signal_id;
>
>      type = IA__g_type_parent (type);
>    }
>  while (type);
>
>
>  ifaces = IA__g_type_interfaces (itype, &n_ifaces);
>  while (n_ifaces--)
>    {
>      SignalKey *signal_key;
>
>      key.itype = ifaces[n_ifaces];
>      signal_key = g_bsearch_array_lookup_fuzzy ((g_signal_key_bsa), (&g_signal_key_bconfig), (&key), 0);
>
>      if (signal_key)
> {
>   g_free (ifaces);
>   return signal_key->signal_id;
> }
>    }
>  g_free (ifaces);
>
>  return 0;
>}
>
>static gint
>class_closures_cmp (gconstpointer node1,
>      gconstpointer node2)
>{
>  const ClassClosure *c1 = node1, *c2 = node2;
>
>  return ((c1->instance_type) > (c2->instance_type) ? +1 : (c1->instance_type) == (c2->instance_type) ? 0 : -1);
>}
>
>static gint
>handler_lists_cmp (gconstpointer node1,
>                   gconstpointer node2)
>{
>  const HandlerList *hlist1 = node1, *hlist2 = node2;
>
>  return ((hlist1->signal_id) > (hlist2->signal_id) ? +1 : (hlist1->signal_id) == (hlist2->signal_id) ? 0 : -1);
>}
>
>static inline HandlerList*
>handler_list_ensure (guint signal_id,
>       gpointer instance)
>{
>  GBSearchArray *hlbsa = g_hash_table_lookup (g_handler_list_bsa_ht, instance);
>  HandlerList key;
>
>  key.signal_id = signal_id;
>  key.handlers = ((void *)0);
>  key.tail_before = ((void *)0);
>  key.tail_after = ((void *)0);
>  if (!hlbsa)
>    {
>      hlbsa = g_bsearch_array_create (&g_signal_hlbsa_bconfig);
>      hlbsa = g_bsearch_array_insert (hlbsa, &g_signal_hlbsa_bconfig, &key);
>      g_hash_table_insert (g_handler_list_bsa_ht, instance, hlbsa);
>    }
>  else
>    {
>      GBSearchArray *o = hlbsa;
>
>      hlbsa = g_bsearch_array_insert (o, &g_signal_hlbsa_bconfig, &key);
>      if (hlbsa != o)
> g_hash_table_insert (g_handler_list_bsa_ht, instance, hlbsa);
>    }
>  return g_bsearch_array_lookup_fuzzy ((hlbsa), (&g_signal_hlbsa_bconfig), (&key), 0);
>}
>
>static inline HandlerList*
>handler_list_lookup (guint signal_id,
>       gpointer instance)
>{
>  GBSearchArray *hlbsa = g_hash_table_lookup (g_handler_list_bsa_ht, instance);
>  HandlerList key;
>
>  key.signal_id = signal_id;
>
>  return hlbsa ? g_bsearch_array_lookup_fuzzy ((hlbsa), (&g_signal_hlbsa_bconfig), (&key), 0) : ((void *)0);
>}
>
>static Handler*
>handler_lookup (gpointer instance,
>  gulong handler_id,
>  guint *signal_id_p)
>{
>  GBSearchArray *hlbsa = g_hash_table_lookup (g_handler_list_bsa_ht, instance);
>
>  if (hlbsa)
>    {
>      guint i;
>
>      for (i = 0; i < hlbsa->n_nodes; i++)
>        {
>          HandlerList *hlist = g_bsearch_array_get_nth (hlbsa, &g_signal_hlbsa_bconfig, i);
>          Handler *handler;
>
>          for (handler = hlist->handlers; handler; handler = handler->next)
>            if (handler->sequential_number == handler_id)
>              {
>                if (signal_id_p)
>                  *signal_id_p = hlist->signal_id;
>
>                return handler;
>              }
>        }
>    }
>
>  return ((void *)0);
>}
>
>static inline HandlerMatch*
>handler_match_prepend (HandlerMatch *list,
>         Handler *handler,
>         guint signal_id)
>{
>  HandlerMatch *node;
>
>  node = ((HandlerMatch*) g_slice_alloc (sizeof (HandlerMatch)));
>  node->handler = handler;
>  node->next = list;
>  node->signal_id = signal_id;
>  handler_ref (handler);
>
>  return node;
>}
>static inline HandlerMatch*
>handler_match_free1_R (HandlerMatch *node,
>         gpointer instance)
>{
>  HandlerMatch *next = node->next;
>
>  handler_unref_R (node->signal_id, instance, node->handler);
>  do { if (1) g_slice_free1 (sizeof (HandlerMatch), (node)); else (void) ((HandlerMatch*) 0 == (node)); } while (0);
>
>  return next;
>}
>
>static HandlerMatch*
>handlers_find (gpointer instance,
>        GSignalMatchType mask,
>        guint signal_id,
>        GQuark detail,
>        GClosure *closure,
>        gpointer func,
>        gpointer data,
>        gboolean one_and_only)
>{
>  HandlerMatch *mlist = ((void *)0);
>
>  if (mask & G_SIGNAL_MATCH_ID)
>    {
>      HandlerList *hlist = handler_list_lookup (signal_id, instance);
>      Handler *handler;
>      SignalNode *node = ((void *)0);
>
>      if (mask & G_SIGNAL_MATCH_FUNC)
> {
>   node = LOOKUP_SIGNAL_NODE (signal_id);
>   if (!node || !node->c_marshaller)
>     return ((void *)0);
> }
>
>      mask = ~mask;
>      for (handler = hlist ? hlist->handlers : ((void *)0); handler; handler = handler->next)
>        if (handler->sequential_number &&
>     ((mask & G_SIGNAL_MATCH_DETAIL) || handler->detail == detail) &&
>     ((mask & G_SIGNAL_MATCH_CLOSURE) || handler->closure == closure) &&
>            ((mask & G_SIGNAL_MATCH_DATA) || handler->closure->data == data) &&
>     ((mask & G_SIGNAL_MATCH_UNBLOCKED) || handler->block_count == 0) &&
>     ((mask & G_SIGNAL_MATCH_FUNC) || (handler->closure->marshal == node->c_marshaller &&
>           handler->closure->meta_marshal == 0 &&
>           ((GCClosure*) handler->closure)->callback == func)))
>   {
>     mlist = handler_match_prepend (mlist, handler, signal_id);
>     if (one_and_only)
>       return mlist;
>   }
>    }
>  else
>    {
>      GBSearchArray *hlbsa = g_hash_table_lookup (g_handler_list_bsa_ht, instance);
>
>      mask = ~mask;
>      if (hlbsa)
>        {
>          guint i;
>
>          for (i = 0; i < hlbsa->n_nodes; i++)
>            {
>              HandlerList *hlist = g_bsearch_array_get_nth (hlbsa, &g_signal_hlbsa_bconfig, i);
>       SignalNode *node = ((void *)0);
>              Handler *handler;
>
>       if (!(mask & G_SIGNAL_MATCH_FUNC))
>  {
>    node = LOOKUP_SIGNAL_NODE (hlist->signal_id);
>    if (!node->c_marshaller)
>      continue;
>  }
>
>              for (handler = hlist->handlers; handler; handler = handler->next)
>  if (handler->sequential_number &&
>      ((mask & G_SIGNAL_MATCH_DETAIL) || handler->detail == detail) &&
>                    ((mask & G_SIGNAL_MATCH_CLOSURE) || handler->closure == closure) &&
>                    ((mask & G_SIGNAL_MATCH_DATA) || handler->closure->data == data) &&
>      ((mask & G_SIGNAL_MATCH_UNBLOCKED) || handler->block_count == 0) &&
>      ((mask & G_SIGNAL_MATCH_FUNC) || (handler->closure->marshal == node->c_marshaller &&
>            handler->closure->meta_marshal == 0 &&
>            ((GCClosure*) handler->closure)->callback == func)))
>    {
>      mlist = handler_match_prepend (mlist, handler, hlist->signal_id);
>      if (one_and_only)
>        return mlist;
>    }
>            }
>        }
>    }
>
>  return mlist;
>}
>
>static inline Handler*
>handler_new (gboolean after)
>{
>  Handler *handler = ((Handler*) g_slice_alloc (sizeof (Handler)));
>
>  if (g_handler_sequential_number < 1)
>    (void) __extension__ ( { g_log ("GLib-GObject", G_LOG_LEVEL_ERROR, "gsignal.c" ":" "502" ": handler id overflow, %s", "please report occurrence circumstances to gtk-devel-list@gnome.org"); for (;;); } );
>
>
>  handler->sequential_number = g_handler_sequential_number++;
>  handler->prev = ((void *)0);
>  handler->next = ((void *)0);
>  handler->detail = 0;
>  handler->ref_count = 1;
>  handler->block_count = 0;
>  handler->after = after != (0);
>  handler->closure = ((void *)0);
>
>  return handler;
>}
>
>static inline void
>handler_ref (Handler *handler)
>{
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (handler->ref_count > 0) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "handler->ref_count > 0"); return; }; });
>
>  (g_atomic_int_add ((&handler->ref_count), 1));
>}
>
>static inline void
>handler_unref_R (guint signal_id,
>   gpointer instance,
>   Handler *handler)
>{
>  gboolean is_zero;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (handler->ref_count > 0) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "handler->ref_count > 0"); return; }; });
>
>  is_zero = (g_atomic_int_exchange_and_add ((&handler->ref_count), -1) == 1);
>
>  if ((__builtin_expect (__extension__ ({ int _g_boolean_var_; if (is_zero) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 0)))
>    {
>      HandlerList *hlist = ((void *)0);
>
>      if (handler->next)
>        handler->next->prev = handler->prev;
>      if (handler->prev)
>        handler->prev->next = handler->next;
>      else
>        {
>          hlist = handler_list_lookup (signal_id, instance);
>          hlist->handlers = handler->next;
>        }
>
>      if (instance)
>        {
>
>          if (!handler->after && (!handler->next || handler->next->after))
>            {
>              if (!hlist)
>                hlist = handler_list_lookup (signal_id, instance);
>              if (hlist)
>                {
>                  do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (hlist->tail_before == handler) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) ; else g_assertion_message_expr ("GLib-GObject", "gsignal.c", 559, ((const char*) (__PRETTY_FUNCTION__)), "hlist->tail_before == handler"); } while (0);
>                  hlist->tail_before = handler->prev;
>                }
>            }
>
>
>          if (!handler->next)
>            {
>              if (!hlist)
>                hlist = handler_list_lookup (signal_id, instance);
>              if (hlist)
>                {
>                  do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (hlist->tail_after == handler) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) ; else g_assertion_message_expr ("GLib-GObject", "gsignal.c", 571, ((const char*) (__PRETTY_FUNCTION__)), "hlist->tail_after == handler"); } while (0);
>                  hlist->tail_after = handler->prev;
>                }
>            }
>        }
>
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      IA__g_closure_unref (handler->closure);
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      do { if (1) g_slice_free1 (sizeof (Handler), (handler)); else (void) ((Handler*) 0 == (handler)); } while (0);
>    }
>}
>
>static void
>handler_insert (guint signal_id,
>  gpointer instance,
>  Handler *handler)
>{
>  HandlerList *hlist;
>
>  do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (handler->prev == ((void *)0) && handler->next == ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) ; else g_assertion_message_expr ("GLib-GObject", "gsignal.c", 591, ((const char*) (__PRETTY_FUNCTION__)), "handler->prev == NULL && handler->next == NULL"); } while (0);
>
>  hlist = handler_list_ensure (signal_id, instance);
>  if (!hlist->handlers)
>    {
>      hlist->handlers = handler;
>      if (!handler->after)
>        hlist->tail_before = handler;
>    }
>  else if (handler->after)
>    {
>      handler->prev = hlist->tail_after;
>      hlist->tail_after->next = handler;
>    }
>  else
>    {
>      if (hlist->tail_before)
>        {
>          handler->next = hlist->tail_before->next;
>          if (handler->next)
>            handler->next->prev = handler;
>          handler->prev = hlist->tail_before;
>          hlist->tail_before->next = handler;
>        }
>      else
>        {
>          handler->next = hlist->handlers;
>          if (handler->next)
>            handler->next->prev = handler;
>          hlist->handlers = handler;
>        }
>      hlist->tail_before = handler;
>    }
>
>  if (!handler->next)
>    hlist->tail_after = handler;
>}
>
>static inline void
>emission_push (Emission **emission_list_p,
>        Emission *emission)
>{
>  emission->next = *emission_list_p;
>  *emission_list_p = emission;
>}
>
>static inline void
>emission_pop (Emission **emission_list_p,
>       Emission *emission)
>{
>  Emission *node, *last = ((void *)0);
>
>  for (node = *emission_list_p; node; last = node, node = last->next)
>    if (node == emission)
>      {
> if (last)
>   last->next = node->next;
> else
>   *emission_list_p = node->next;
> return;
>      }
>  do { g_assertion_message ("GLib-GObject", "gsignal.c", 652, ((const char*) (__PRETTY_FUNCTION__)), ((void *)0)); } while (0);
>}
>
>static inline Emission*
>emission_find (Emission *emission_list,
>        guint signal_id,
>        GQuark detail,
>        gpointer instance)
>{
>  Emission *emission;
>
>  for (emission = emission_list; emission; emission = emission->next)
>    if (emission->instance == instance &&
> emission->ihint.signal_id == signal_id &&
> emission->ihint.detail == detail)
>      return emission;
>  return ((void *)0);
>}
>
>static inline Emission*
>emission_find_innermost (gpointer instance)
>{
>  Emission *emission, *s = ((void *)0), *c = ((void *)0);
>
>  for (emission = g_restart_emissions; emission; emission = emission->next)
>    if (emission->instance == instance)
>      {
> s = emission;
> break;
>      }
>  for (emission = g_recursive_emissions; emission; emission = emission->next)
>    if (emission->instance == instance)
>      {
> c = emission;
> break;
>      }
>  if (!s)
>    return c;
>  else if (!c)
>    return s;
>  else
>    return 0 ? (((c) > (s)) ? (c) : (s)) : (((c) < (s)) ? (c) : (s));
>}
>
>static gint
>signal_key_cmp (gconstpointer node1,
>                gconstpointer node2)
>{
>  const SignalKey *key1 = node1, *key2 = node2;
>
>  if (key1->itype == key2->itype)
>    return ((key1->quark) > (key2->quark) ? +1 : (key1->quark) == (key2->quark) ? 0 : -1);
>  else
>    return ((key1->itype) > (key2->itype) ? +1 : (key1->itype) == (key2->itype) ? 0 : -1);
>}
>
>void
>g_signal_init (void)
>{
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  if (!g_n_signal_nodes)
>    {
>
>      g_handler_list_bsa_ht = g_hash_table_new (g_direct_hash, ((void *)0));
>      g_signal_key_bsa = g_bsearch_array_create (&g_signal_key_bconfig);
>
>
>      g_n_signal_nodes = 1;
>      g_signal_nodes = ((SignalNode* *) g_realloc ((g_signal_nodes), ((gsize) sizeof (SignalNode*)) * ((gsize) (g_n_signal_nodes))));
>      g_signal_nodes[0] = ((void *)0);
>    }
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>}
>
>void
>_g_signals_destroy (GType itype)
>{
>  guint i;
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  for (i = 1; i < g_n_signal_nodes; i++)
>    {
>      SignalNode *node = g_signal_nodes[i];
>
>      if (node->itype == itype)
>        {
>          if (node->destroyed)
>            g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "gsignal.c" ":" "741" ": signal \"%s\" of type `%s' already destroyed", node->name, type_debug_name (node->itype));
>
>
>          else
>     signal_destroy_R (node);
>        }
>    }
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>}
>
>void
>IA__g_signal_stop_emission (gpointer instance,
>                        guint signal_id,
>   GQuark detail)
>{
>  SignalNode *node;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (((IA__g_type_check_instance ((GTypeInstance*) (GTypeInstance*) (instance))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_CHECK_INSTANCE (instance)"); return; }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (signal_id > 0) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "signal_id > 0"); return; }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  node = LOOKUP_SIGNAL_NODE (signal_id);
>  if (node && detail && !(node->flags & G_SIGNAL_DETAILED))
>    {
>      g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal id `%u' does not support detail (%u)", "gsignal.c" ":" "763", signal_id, detail);
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      return;
>    }
>  if (node && IA__g_type_is_a (((((GTypeClass*) (((GTypeInstance*) (instance))->g_class))->g_type)), node->itype))
>    {
>      Emission *emission_list = node->flags & G_SIGNAL_NO_RECURSE ? g_restart_emissions : g_recursive_emissions;
>      Emission *emission = emission_find (emission_list, signal_id, detail, instance);
>
>      if (emission)
>        {
>          if (emission->state == EMISSION_HOOK)
>            g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "gsignal.c" ":" "776" ": emission of signal \"%s\" for instance `%p' cannot be stopped from emission hook", node->name, instance);
>
>          else if (emission->state == EMISSION_RUN)
>            emission->state = EMISSION_STOP;
>        }
>      else
>        g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "gsignal.c" ":" "782" ": no emission of signal \"%s\" to stop for instance `%p'", node->name, instance);
>
>    }
>  else
>    g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal id `%u' is invalid for instance `%p'", "gsignal.c" ":" "785", signal_id, instance);
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>}
>
>static void
>signal_finalize_hook (GHookList *hook_list,
>        GHook *hook)
>{
>  GDestroyNotify destroy = hook->destroy;
>
>  if (destroy)
>    {
>      hook->destroy = ((void *)0);
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      destroy (hook->data);
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>    }
>}
>
>gulong
>IA__g_signal_add_emission_hook (guint signal_id,
>       GQuark detail,
>       GSignalEmissionHook hook_func,
>       gpointer hook_data,
>       GDestroyNotify data_destroy)
>{
>  static gulong seq_hook_id = 1;
>  SignalNode *node;
>  GHook *hook;
>  SignalHook *signal_hook;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (signal_id > 0) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "signal_id > 0"); return (0); }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (hook_func != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "hook_func != NULL"); return (0); }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  node = LOOKUP_SIGNAL_NODE (signal_id);
>  if (!node || node->destroyed)
>    {
>      g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: invalid signal id `%u'", "gsignal.c" ":" "823", signal_id);
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      return 0;
>    }
>  if (node->flags & G_SIGNAL_NO_HOOKS)
>    {
>      g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal id `%u' does not support emission hooks (G_SIGNAL_NO_HOOKS flag set)", "gsignal.c" ":" "829", signal_id);
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      return 0;
>    }
>  if (detail && !(node->flags & G_SIGNAL_DETAILED))
>    {
>      g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal id `%u' does not support detail (%u)", "gsignal.c" ":" "835", signal_id, detail);
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      return 0;
>    }
>  if (!node->emission_hooks)
>    {
>      node->emission_hooks = ((GHookList *) g_malloc (((gsize) sizeof (GHookList)) * ((gsize) (1))));
>      g_hook_list_init (node->emission_hooks, sizeof (SignalHook));
>      node->emission_hooks->finalize_hook = signal_finalize_hook;
>    }
>  hook = g_hook_alloc (node->emission_hooks);
>  hook->data = hook_data;
>  hook->func = (gpointer) hook_func;
>  hook->destroy = data_destroy;
>  signal_hook = ((SignalHook*) (hook));
>  signal_hook->detail = detail;
>  node->emission_hooks->seq_id = seq_hook_id;
>  g_hook_insert_before ((node->emission_hooks), ((void *)0), (hook));
>  seq_hook_id = node->emission_hooks->seq_id;
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>
>  return hook->hook_id;
>}
>
>void
>IA__g_signal_remove_emission_hook (guint signal_id,
>          gulong hook_id)
>{
>  SignalNode *node;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (signal_id > 0) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "signal_id > 0"); return; }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (hook_id > 0) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "hook_id > 0"); return; }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  node = LOOKUP_SIGNAL_NODE (signal_id);
>  if (!node || node->destroyed)
>    g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: invalid signal id `%u'", "gsignal.c" ":" "871", signal_id);
>  else if (!node->emission_hooks || !g_hook_destroy (node->emission_hooks, hook_id))
>    g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal \"%s\" had no hook (%lu) to remove", "gsignal.c" ":" "873", node->name, hook_id);
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>}
>
>static inline guint
>signal_parse_name (const gchar *name,
>     GType itype,
>     GQuark *detail_p,
>     gboolean force_quark)
>{
>  const gchar *colon = (__extension__ (__builtin_constant_p (':') && !__builtin_constant_p (name) && (':') == '\0' ? (char *) __rawmemchr (name, ':') : __builtin_strchr (name, ':')));
>  guint signal_id;
>
>  if (!colon)
>    {
>      signal_id = signal_id_lookup (g_quark_try_string (name), itype);
>      if (signal_id && detail_p)
> *detail_p = 0;
>    }
>  else if (colon[1] == ':')
>    {
>      gchar buffer[32];
>      guint l = colon - name;
>
>      if (l < 32)
> {
>   memcpy (buffer, name, l);
>   buffer[l] = 0;
>   signal_id = signal_id_lookup (g_quark_try_string (buffer), itype);
> }
>      else
> {
>   gchar *signal = ((gchar *) g_malloc (((gsize) sizeof (gchar)) * ((gsize) (l + 1))));
>
>   memcpy (signal, name, l);
>   signal[l] = 0;
>   signal_id = signal_id_lookup (g_quark_try_string (signal), itype);
>   g_free (signal);
> }
>
>      if (signal_id && detail_p)
> *detail_p = colon[2] ? (force_quark ? g_quark_from_string : g_quark_try_string) (colon + 2) : 0;
>    }
>  else
>    signal_id = 0;
>  return signal_id;
>}
>
>gboolean
>IA__g_signal_parse_name (const gchar *detailed_signal,
>       GType itype,
>       guint *signal_id_p,
>       GQuark *detail_p,
>       gboolean force_detail_quark)
>{
>  SignalNode *node;
>  GQuark detail = 0;
>  guint signal_id;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (detailed_signal != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "detailed_signal != NULL"); return ((0)); }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if ((IA__g_type_test_flags ((itype), G_TYPE_FLAG_INSTANTIATABLE)) || ((IA__g_type_fundamental (itype)) == ((GType) ((2) << (2))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_IS_INSTANTIATABLE (itype) || G_TYPE_IS_INTERFACE (itype)"); return ((0)); }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  signal_id = signal_parse_name (detailed_signal, itype, &detail, force_detail_quark);
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>
>  node = signal_id ? LOOKUP_SIGNAL_NODE (signal_id) : ((void *)0);
>  if (!node || node->destroyed ||
>      (detail && !(node->flags & G_SIGNAL_DETAILED)))
>    return (0);
>
>  if (signal_id_p)
>    *signal_id_p = signal_id;
>  if (detail_p)
>    *detail_p = detail;
>
>  return (!(0));
>}
>
>void
>IA__g_signal_stop_emission_by_name (gpointer instance,
>    const gchar *detailed_signal)
>{
>  guint signal_id;
>  GQuark detail = 0;
>  GType itype;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (((IA__g_type_check_instance ((GTypeInstance*) (GTypeInstance*) (instance))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_CHECK_INSTANCE (instance)"); return; }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (detailed_signal != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "detailed_signal != NULL"); return; }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  itype = ((((GTypeClass*) (((GTypeInstance*) (instance))->g_class))->g_type));
>  signal_id = signal_parse_name (detailed_signal, itype, &detail, (!(0)));
>  if (signal_id)
>    {
>      SignalNode *node = LOOKUP_SIGNAL_NODE (signal_id);
>
>      if (detail && !(node->flags & G_SIGNAL_DETAILED))
> g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal `%s' does not support details", "gsignal.c" ":" "971", detailed_signal);
>      else if (!IA__g_type_is_a (itype, node->itype))
> g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal `%s' is invalid for instance `%p'", "gsignal.c" ":" "973", detailed_signal, instance);
>      else
> {
>   Emission *emission_list = node->flags & G_SIGNAL_NO_RECURSE ? g_restart_emissions : g_recursive_emissions;
>   Emission *emission = emission_find (emission_list, signal_id, detail, instance);
>
>   if (emission)
>     {
>       if (emission->state == EMISSION_HOOK)
>  g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "gsignal.c" ":" "983" ": emission of signal \"%s\" for instance `%p' cannot be stopped from emission hook", node->name, instance);
>
>       else if (emission->state == EMISSION_RUN)
>  emission->state = EMISSION_STOP;
>     }
>   else
>     g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "gsignal.c" ":" "989" ": no emission of signal \"%s\" to stop for instance `%p'", node->name, instance);
>
> }
>    }
>  else
>    g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal `%s' is invalid for instance `%p'", "gsignal.c" ":" "993", detailed_signal, instance);
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>}
>
>guint
>IA__g_signal_lookup (const gchar *name,
>                 GType itype)
>{
>  guint signal_id;
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (name != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "name != NULL"); return (0); }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if ((IA__g_type_test_flags ((itype), G_TYPE_FLAG_INSTANTIATABLE)) || ((IA__g_type_fundamental (itype)) == ((GType) ((2) << (2))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_IS_INSTANTIATABLE (itype) || G_TYPE_IS_INTERFACE (itype)"); return (0); }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  signal_id = signal_id_lookup (g_quark_try_string (name), itype);
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  if (!signal_id)
>    {
>
>      if (!IA__g_type_name (itype))
> g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "gsignal.c" ":" "1013" ": unable to lookup signal \"%s\" for invalid type id `%lu'", name, itype);
>
>      else if (!(IA__g_type_test_flags ((itype), G_TYPE_FLAG_INSTANTIATABLE)))
> g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "gsignal.c" ":" "1016" ": unable to lookup signal \"%s\" for non instantiatable type `%s'", name, IA__g_type_name (itype));
>
>      else if (!IA__g_type_class_peek (itype))
> g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "gsignal.c" ":" "1019" ": unable to lookup signal \"%s\" of unloaded type `%s'", name, IA__g_type_name (itype));
>
>    }
>
>  return signal_id;
>}
>
>guint*
>IA__g_signal_list_ids (GType itype,
>     guint *n_ids)
>{
>  SignalKey *keys;
>  GArray *result;
>  guint n_nodes;
>  guint i;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if ((IA__g_type_test_flags ((itype), G_TYPE_FLAG_INSTANTIATABLE)) || ((IA__g_type_fundamental (itype)) == ((GType) ((2) << (2))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_IS_INSTANTIATABLE (itype) || G_TYPE_IS_INTERFACE (itype)"); return (((void *)0)); }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_ids != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_ids != NULL"); return (((void *)0)); }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  keys = g_bsearch_array_get_nth (g_signal_key_bsa, &g_signal_key_bconfig, 0);
>  n_nodes = (((GBSearchArray*) (g_signal_key_bsa))->n_nodes);
>  result = g_array_new ((0), (0), sizeof (guint));
>
>  for (i = 0; i < n_nodes; i++)
>    if (keys[i].itype == itype)
>      {
> const gchar *name = g_quark_to_string (keys[i].quark);
>
>
>
>
> if (!(__extension__ (__builtin_constant_p ('_') && !__builtin_constant_p (name) && ('_') == '\0' ? (char *) __rawmemchr (name, '_') : __builtin_strchr (name, '_'))))
>   g_array_append_vals (result, &(keys[i].signal_id), 1);
>      }
>  *n_ids = result->len;
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  if (!n_nodes)
>    {
>
>      if (!IA__g_type_name (itype))
> g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "gsignal.c" ":" "1060" ": unable to list signals for invalid type id `%lu'", itype);
>
>      else if (!(IA__g_type_test_flags ((itype), G_TYPE_FLAG_INSTANTIATABLE)) && !((IA__g_type_fundamental (itype)) == ((GType) ((2) << (2)))))
> g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "gsignal.c" ":" "1063" ": unable to list signals of non instantiatable type `%s'", IA__g_type_name (itype));
>
>      else if (!IA__g_type_class_peek (itype) && !((IA__g_type_fundamental (itype)) == ((GType) ((2) << (2)))))
> g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "gsignal.c" ":" "1066" ": unable to list signals of unloaded type `%s'", IA__g_type_name (itype));
>
>    }
>
>  return (guint*) g_array_free (result, (0));
>}
>
> gchar*
>IA__g_signal_name (guint signal_id)
>{
>  SignalNode *node;
>  const gchar *name;
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  node = LOOKUP_SIGNAL_NODE (signal_id);
>  name = node ? node->name : ((void *)0);
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>
>  return (char*) name;
>}
>
>void
>IA__g_signal_query (guint signal_id,
>  GSignalQuery *query)
>{
>  SignalNode *node;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (query != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "query != NULL"); return; }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  node = LOOKUP_SIGNAL_NODE (signal_id);
>  if (!node || node->destroyed)
>    query->signal_id = 0;
>  else
>    {
>      query->signal_id = node->signal_id;
>      query->signal_name = node->name;
>      query->itype = node->itype;
>      query->signal_flags = node->flags;
>      query->return_type = node->return_type;
>      query->n_params = node->n_params;
>      query->param_types = node->param_types;
>    }
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>}
>
>guint
>IA__g_signal_new (const gchar *signal_name,
>       GType itype,
>       GSignalFlags signal_flags,
>       guint class_offset,
>       GSignalAccumulator accumulator,
>       gpointer accu_data,
>       GSignalCMarshaller c_marshaller,
>       GType return_type,
>       guint n_params,
>       ...)
>{
>  va_list args;
>  guint signal_id;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (signal_name != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "signal_name != NULL"); return (0); }; });
>
>  __builtin_va_start(args,n_params);
>
>  signal_id = IA__g_signal_new_valist (signal_name, itype, signal_flags,
>                                   class_offset ? IA__g_signal_type_cclosure_new (itype, class_offset) : ((void *)0),
>       accumulator, accu_data, c_marshaller,
>                                   return_type, n_params, args);
>
>  __builtin_va_end(args);
>
>
>  if (signal_id && (IA__g_type_test_flags ((itype), G_TYPE_FLAG_INSTANTIATABLE)) && return_type == ((GType) ((1) << (2))) &&
>      class_offset && class_offset < (4096))
>    {
>      SignalNode *node;
>
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      node = LOOKUP_SIGNAL_NODE (signal_id);
>      node->test_class_offset = class_offset;
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>    }
>
>  return signal_id;
>}
>
>static inline ClassClosure*
>signal_find_class_closure (SignalNode *node,
>      GType itype)
>{
>  GBSearchArray *bsa = node->class_closure_bsa;
>  ClassClosure *cc;
>
>  if (bsa)
>    {
>      ClassClosure key;
>
>
>
>      key.instance_type = itype;
>      cc = g_bsearch_array_lookup_fuzzy ((bsa), (&g_class_closure_bconfig), (&key), 0);
>      while (!cc && key.instance_type)
> {
>   key.instance_type = IA__g_type_parent (key.instance_type);
>   cc = g_bsearch_array_lookup_fuzzy ((bsa), (&g_class_closure_bconfig), (&key), 0);
> }
>    }
>  else
>    cc = ((void *)0);
>  return cc;
>}
>
>static inline GClosure*
>signal_lookup_closure (SignalNode *node,
>         GTypeInstance *instance)
>{
>  ClassClosure *cc;
>
>  if (node->class_closure_bsa && (((GBSearchArray*) (node->class_closure_bsa))->n_nodes) == 1)
>    cc = g_bsearch_array_get_nth (node->class_closure_bsa, &g_class_closure_bconfig, 0);
>  else
>    cc = signal_find_class_closure (node, ((((GTypeClass*) (((GTypeInstance*) (instance))->g_class))->g_type)));
>  return cc ? cc->closure : ((void *)0);
>}
>
>static void
>signal_add_class_closure (SignalNode *node,
>     GType itype,
>     GClosure *closure)
>{
>  ClassClosure key;
>
>
>  node->test_class_offset = 0;
>
>  if (!node->class_closure_bsa)
>    node->class_closure_bsa = g_bsearch_array_create (&g_class_closure_bconfig);
>  key.instance_type = itype;
>  key.closure = IA__g_closure_ref (closure);
>  node->class_closure_bsa = g_bsearch_array_insert (node->class_closure_bsa,
>          &g_class_closure_bconfig,
>          &key);
>  IA__g_closure_sink (closure);
>  if (node->c_marshaller && closure && (((GClosure*) (closure))->marshal == ((void *)0)))
>    IA__g_closure_set_marshal (closure, node->c_marshaller);
>}
>
>guint
>IA__g_signal_newv (const gchar *signal_name,
>               GType itype,
>               GSignalFlags signal_flags,
>               GClosure *class_closure,
>               GSignalAccumulator accumulator,
>        gpointer accu_data,
>               GSignalCMarshaller c_marshaller,
>               GType return_type,
>               guint n_params,
>               GType *param_types)
>{
>  gchar *name;
>  guint signal_id, i;
>  SignalNode *node;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (signal_name != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "signal_name != NULL"); return (0); }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if ((IA__g_type_test_flags ((itype), G_TYPE_FLAG_INSTANTIATABLE)) || ((IA__g_type_fundamental (itype)) == ((GType) ((2) << (2))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_IS_INSTANTIATABLE (itype) || G_TYPE_IS_INTERFACE (itype)"); return (0); }; });
>  if (n_params)
>    (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (param_types != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "param_types != NULL"); return (0); }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if ((return_type & (((GType) (1 << 0)))) == 0) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "(return_type & G_SIGNAL_TYPE_STATIC_SCOPE) == 0"); return (0); }; });
>  if (return_type == (((GType) ((1) << (2))) & ~(((GType) (1 << 0)))))
>    (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (accumulator == ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "accumulator == NULL"); return (0); }; });
>  if (!accumulator)
>    (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (accu_data == ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "accu_data == NULL"); return (0); }; });
>
>  name = g_strdup (signal_name);
>  g_strdelimit (name, "_-|> <." ":^", '_');
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>
>  signal_id = signal_id_lookup (g_quark_try_string (name), itype);
>  node = LOOKUP_SIGNAL_NODE (signal_id);
>  if (node && !node->destroyed)
>    {
>      g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "gsignal.c" ":" "1251" ": signal \"%s\" already exists in the `%s' %s", name, type_debug_name (node->itype), ((IA__g_type_fundamental (node->itype)) == ((GType) ((2) << (2)))) ? "interface" : "class ancestry");
>
>
>
>      g_free (name);
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      return 0;
>    }
>  if (node && node->itype != itype)
>    {
>      g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "gsignal.c" ":" "1261" ": signal \"%s\" for type `%s' was previously created for type `%s'", name, type_debug_name (itype), type_debug_name (node->itype));
>
>
>
>      g_free (name);
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      return 0;
>    }
>  for (i = 0; i < n_params; i++)
>    if (!(IA__g_type_check_is_value_type (param_types[i] & ~(((GType) (1 << 0))))))
>      {
> g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "gsignal.c" ":" "1270" ": parameter %d of type `%s' for signal \"%s::%s\" is not a value type", i + 1, type_debug_name (param_types[i]), type_debug_name (itype), name);
>
> g_free (name);
> ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
> return 0;
>      }
>  if (return_type != ((GType) ((1) << (2))) && !(IA__g_type_check_is_value_type (return_type & ~(((GType) (1 << 0))))))
>    {
>      g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "gsignal.c" ":" "1278" ": return value of type `%s' for signal \"%s::%s\" is not a value type", type_debug_name (return_type), type_debug_name (itype), name);
>
>      g_free (name);
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      return 0;
>    }
>  if (return_type != ((GType) ((1) << (2))) &&
>      (signal_flags & (G_SIGNAL_RUN_FIRST | G_SIGNAL_RUN_LAST | G_SIGNAL_RUN_CLEANUP)) == G_SIGNAL_RUN_FIRST)
>    {
>      g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "gsignal.c" ":" "1287" ": signal \"%s::%s\" has return type `%s' and is only G_SIGNAL_RUN_FIRST", type_debug_name (itype), name, type_debug_name (return_type));
>
>      g_free (name);
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      return 0;
>    }
>
>
>  if (!node)
>    {
>      SignalKey key;
>
>      signal_id = g_n_signal_nodes++;
>      node = ((SignalNode *) g_malloc (((gsize) sizeof (SignalNode)) * ((gsize) (1))));
>      node->signal_id = signal_id;
>      g_signal_nodes = ((SignalNode* *) g_realloc ((g_signal_nodes), ((gsize) sizeof (SignalNode*)) * ((gsize) (g_n_signal_nodes))));
>      g_signal_nodes[signal_id] = node;
>      node->itype = itype;
>      node->name = name;
>      key.itype = itype;
>      key.quark = g_quark_from_string (node->name);
>      key.signal_id = signal_id;
>      g_signal_key_bsa = g_bsearch_array_insert (g_signal_key_bsa, &g_signal_key_bconfig, &key);
>      g_strdelimit (name, "_", '-');
>      node->name = g_intern_string (name);
>      key.quark = g_quark_from_string (name);
>      g_signal_key_bsa = g_bsearch_array_insert (g_signal_key_bsa, &g_signal_key_bconfig, &key);
>    }
>  node->destroyed = (0);
>  node->test_class_offset = 0;
>
>
>  node->flags = signal_flags & 0x7f;
>  node->n_params = n_params;
>  node->param_types = g_memdup (param_types, sizeof (GType) * n_params);
>  node->return_type = return_type;
>  node->class_closure_bsa = ((void *)0);
>  if (accumulator)
>    {
>      node->accumulator = ((SignalAccumulator *) g_malloc (((gsize) sizeof (SignalAccumulator)) * ((gsize) (1))));
>      node->accumulator->func = accumulator;
>      node->accumulator->data = accu_data;
>    }
>  else
>    node->accumulator = ((void *)0);
>  node->c_marshaller = c_marshaller;
>  node->emission_hooks = ((void *)0);
>  if (class_closure)
>    signal_add_class_closure (node, 0, class_closure);
>  else if ((IA__g_type_test_flags ((itype), G_TYPE_FLAG_INSTANTIATABLE)) && return_type == ((GType) ((1) << (2))))
>    {
>
>      node->test_class_offset = (1);
>    }
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>
>  g_free (name);
>
>  return signal_id;
>}
>
>guint
>IA__g_signal_new_valist (const gchar *signal_name,
>                     GType itype,
>                     GSignalFlags signal_flags,
>                     GClosure *class_closure,
>                     GSignalAccumulator accumulator,
>       gpointer accu_data,
>                     GSignalCMarshaller c_marshaller,
>                     GType return_type,
>                     guint n_params,
>                     va_list args)
>{
>  GType *param_types;
>  guint i;
>  guint signal_id;
>
>  if (n_params > 0)
>    {
>      param_types = ((GType *) g_malloc (((gsize) sizeof (GType)) * ((gsize) (n_params))));
>
>      for (i = 0; i < n_params; i++)
> param_types[i] = __builtin_va_arg(args,GType);
>    }
>  else
>    param_types = ((void *)0);
>
>  signal_id = IA__g_signal_newv (signal_name, itype, signal_flags,
>        class_closure, accumulator, accu_data, c_marshaller,
>        return_type, n_params, param_types);
>  g_free (param_types);
>
>  return signal_id;
>}
>
>static void
>signal_destroy_R (SignalNode *signal_node)
>{
>  SignalNode node = *signal_node;
>
>  signal_node->destroyed = (!(0));
>
>
>  signal_node->test_class_offset = 0;
>  signal_node->n_params = 0;
>  signal_node->param_types = ((void *)0);
>  signal_node->return_type = 0;
>  signal_node->class_closure_bsa = ((void *)0);
>  signal_node->accumulator = ((void *)0);
>  signal_node->c_marshaller = ((void *)0);
>  signal_node->emission_hooks = ((void *)0);
># 1413 "gsignal.c"
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  g_free (node.param_types);
>  if (node.class_closure_bsa)
>    {
>      guint i;
>
>      for (i = 0; i < node.class_closure_bsa->n_nodes; i++)
> {
>   ClassClosure *cc = g_bsearch_array_get_nth (node.class_closure_bsa, &g_class_closure_bconfig, i);
>
>   IA__g_closure_unref (cc->closure);
> }
>      g_bsearch_array_free (node.class_closure_bsa, &g_class_closure_bconfig);
>    }
>  g_free (node.accumulator);
>  if (node.emission_hooks)
>    {
>      g_hook_list_clear (node.emission_hooks);
>      g_free (node.emission_hooks);
>    }
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>}
>
>void
>IA__g_signal_override_class_closure (guint signal_id,
>     GType instance_type,
>     GClosure *class_closure)
>{
>  SignalNode *node;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (signal_id > 0) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "signal_id > 0"); return; }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (class_closure != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "class_closure != NULL"); return; }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  node = LOOKUP_SIGNAL_NODE (signal_id);
>  if (!IA__g_type_is_a (instance_type, node->itype))
>    g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: type `%s' cannot be overridden for signal id `%u'", "gsignal.c" ":" "1449", type_debug_name (instance_type), signal_id);
>  else
>    {
>      ClassClosure *cc = signal_find_class_closure (node, instance_type);
>
>      if (cc && cc->instance_type == instance_type)
> g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: type `%s' is already overridden for signal id `%u'", "gsignal.c" ":" "1455", type_debug_name (instance_type), signal_id);
>      else
> signal_add_class_closure (node, instance_type, class_closure);
>    }
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>}
>
>void
>IA__g_signal_chain_from_overridden (const GValue *instance_and_params,
>    GValue *return_value)
>{
>  GType chain_type = 0, restore_type = 0;
>  Emission *emission = ((void *)0);
>  GClosure *closure = ((void *)0);
>  guint n_params = 0;
>  gpointer instance;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (instance_and_params != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "instance_and_params != NULL"); return; }; });
>  instance = IA__g_value_peek_pointer (instance_and_params);
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (((IA__g_type_check_instance ((GTypeInstance*) (GTypeInstance*) (instance))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_CHECK_INSTANCE (instance)"); return; }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  emission = emission_find_innermost (instance);
>  if (emission)
>    {
>      SignalNode *node = LOOKUP_SIGNAL_NODE (emission->ihint.signal_id);
>
>      do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (node != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) ; else g_assertion_message_expr ("GLib-GObject", "gsignal.c", 1482, ((const char*) (__PRETTY_FUNCTION__)), "node != NULL"); } while (0);
>
>
>
>      if (emission->chain_type != ((GType) ((1) << (2))))
> {
>   ClassClosure *cc = signal_find_class_closure (node, emission->chain_type);
>
>   do { if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (cc != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) ; else g_assertion_message_expr ("GLib-GObject", "gsignal.c", 1490, ((const char*) (__PRETTY_FUNCTION__)), "cc != NULL"); } while (0);
>
>   n_params = node->n_params;
>   restore_type = cc->instance_type;
>   cc = signal_find_class_closure (node, IA__g_type_parent (cc->instance_type));
>   if (cc && cc->instance_type != restore_type)
>     {
>       closure = cc->closure;
>       chain_type = cc->instance_type;
>     }
> }
>      else
> g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal id `%u' cannot be chained from current emission stage for instance `%p'", "gsignal.c" ":" "1502", node->signal_id, instance);
>    }
>  else
>    g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: no signal is currently being emitted for instance `%p'", "gsignal.c" ":" "1505", instance);
>  if (closure)
>    {
>      emission->chain_type = chain_type;
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      IA__g_closure_invoke (closure,
>   return_value,
>   n_params + 1,
>   instance_and_params,
>   &emission->ihint);
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      emission->chain_type = restore_type;
>    }
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>}
>
>GSignalInvocationHint*
>IA__g_signal_get_invocation_hint (gpointer instance)
>{
>  Emission *emission = ((void *)0);
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (((IA__g_type_check_instance ((GTypeInstance*) (GTypeInstance*) (instance))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_CHECK_INSTANCE (instance)"); return (((void *)0)); }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  emission = emission_find_innermost (instance);
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>
>  return emission ? &emission->ihint : ((void *)0);
>}
>
>gulong
>IA__g_signal_connect_closure_by_id (gpointer instance,
>    guint signal_id,
>    GQuark detail,
>    GClosure *closure,
>    gboolean after)
>{
>  SignalNode *node;
>  gulong handler_seq_no = 0;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (((IA__g_type_check_instance ((GTypeInstance*) (GTypeInstance*) (instance))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_CHECK_INSTANCE (instance)"); return (0); }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (signal_id > 0) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "signal_id > 0"); return (0); }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (closure != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "closure != NULL"); return (0); }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  node = LOOKUP_SIGNAL_NODE (signal_id);
>  if (node)
>    {
>      if (detail && !(node->flags & G_SIGNAL_DETAILED))
> g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal id `%u' does not support detail (%u)", "gsignal.c" ":" "1554", signal_id, detail);
>      else if (!IA__g_type_is_a (((((GTypeClass*) (((GTypeInstance*) (instance))->g_class))->g_type)), node->itype))
> g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal id `%u' is invalid for instance `%p'", "gsignal.c" ":" "1556", signal_id, instance);
>      else
> {
>   Handler *handler = handler_new (after);
>
>   handler_seq_no = handler->sequential_number;
>   handler->detail = detail;
>   handler->closure = IA__g_closure_ref (closure);
>   IA__g_closure_sink (closure);
>   handler_insert (signal_id, instance, handler);
>   if (node->c_marshaller && (((GClosure*) (closure))->marshal == ((void *)0)))
>     IA__g_closure_set_marshal (closure, node->c_marshaller);
> }
>    }
>  else
>    g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal id `%u' is invalid for instance `%p'", "gsignal.c" ":" "1571", signal_id, instance);
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>
>  return handler_seq_no;
>}
>
>gulong
>IA__g_signal_connect_closure (gpointer instance,
>     const gchar *detailed_signal,
>     GClosure *closure,
>     gboolean after)
>{
>  guint signal_id;
>  gulong handler_seq_no = 0;
>  GQuark detail = 0;
>  GType itype;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (((IA__g_type_check_instance ((GTypeInstance*) (GTypeInstance*) (instance))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_CHECK_INSTANCE (instance)"); return (0); }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (detailed_signal != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "detailed_signal != NULL"); return (0); }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (closure != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "closure != NULL"); return (0); }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  itype = ((((GTypeClass*) (((GTypeInstance*) (instance))->g_class))->g_type));
>  signal_id = signal_parse_name (detailed_signal, itype, &detail, (!(0)));
>  if (signal_id)
>    {
>      SignalNode *node = LOOKUP_SIGNAL_NODE (signal_id);
>
>      if (detail && !(node->flags & G_SIGNAL_DETAILED))
> g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal `%s' does not support details", "gsignal.c" ":" "1600", detailed_signal);
>      else if (!IA__g_type_is_a (itype, node->itype))
> g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal `%s' is invalid for instance `%p'", "gsignal.c" ":" "1602", detailed_signal, instance);
>      else
> {
>   Handler *handler = handler_new (after);
>
>   handler_seq_no = handler->sequential_number;
>   handler->detail = detail;
>   handler->closure = IA__g_closure_ref (closure);
>   IA__g_closure_sink (closure);
>   handler_insert (signal_id, instance, handler);
>   if (node->c_marshaller && (((GClosure*) (handler->closure))->marshal == ((void *)0)))
>     IA__g_closure_set_marshal (handler->closure, node->c_marshaller);
> }
>    }
>  else
>    g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal `%s' is invalid for instance `%p'", "gsignal.c" ":" "1617", detailed_signal, instance);
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>
>  return handler_seq_no;
>}
>
>gulong
>IA__g_signal_connect_data (gpointer instance,
>         const gchar *detailed_signal,
>         GCallback c_handler,
>         gpointer data,
>         GClosureNotify destroy_data,
>         GConnectFlags connect_flags)
>{
>  guint signal_id;
>  gulong handler_seq_no = 0;
>  GQuark detail = 0;
>  GType itype;
>  gboolean swapped, after;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (((IA__g_type_check_instance ((GTypeInstance*) (GTypeInstance*) (instance))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_CHECK_INSTANCE (instance)"); return (0); }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (detailed_signal != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "detailed_signal != NULL"); return (0); }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (c_handler != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "c_handler != NULL"); return (0); }; });
>
>  swapped = (connect_flags & G_CONNECT_SWAPPED) != (0);
>  after = (connect_flags & G_CONNECT_AFTER) != (0);
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  itype = ((((GTypeClass*) (((GTypeInstance*) (instance))->g_class))->g_type));
>  signal_id = signal_parse_name (detailed_signal, itype, &detail, (!(0)));
>  if (signal_id)
>    {
>      SignalNode *node = LOOKUP_SIGNAL_NODE (signal_id);
>
>      if (detail && !(node->flags & G_SIGNAL_DETAILED))
> g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal `%s' does not support details", "gsignal.c" ":" "1652", detailed_signal);
>      else if (!IA__g_type_is_a (itype, node->itype))
> g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal `%s' is invalid for instance `%p'", "gsignal.c" ":" "1654", detailed_signal, instance);
>      else
> {
>   Handler *handler = handler_new (after);
>
>   handler_seq_no = handler->sequential_number;
>   handler->detail = detail;
>   handler->closure = IA__g_closure_ref ((swapped ? IA__g_cclosure_new_swap : IA__g_cclosure_new) (c_handler, data, destroy_data));
>   IA__g_closure_sink (handler->closure);
>   handler_insert (signal_id, instance, handler);
>   if (node->c_marshaller && (((GClosure*) (handler->closure))->marshal == ((void *)0)))
>     IA__g_closure_set_marshal (handler->closure, node->c_marshaller);
> }
>    }
>  else
>    g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal `%s' is invalid for instance `%p'", "gsignal.c" ":" "1669", detailed_signal, instance);
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>
>  return handler_seq_no;
>}
>
>void
>IA__g_signal_handler_block (gpointer instance,
>                        gulong handler_id)
>{
>  Handler *handler;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (((IA__g_type_check_instance ((GTypeInstance*) (GTypeInstance*) (instance))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_CHECK_INSTANCE (instance)"); return; }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (handler_id > 0) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "handler_id > 0"); return; }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  handler = handler_lookup (instance, handler_id, ((void *)0));
>  if (handler)
>    {
>
>      if (handler->block_count >= (1 << 16) - 1)
>        (void) __extension__ ( { g_log ("GLib-GObject", G_LOG_LEVEL_ERROR, "gsignal.c" ":" "1690" ": handler block_count overflow, %s", "please report occurrence circumstances to gtk-devel-list@gnome.org"); for (;;); } );
>
>      handler->block_count += 1;
>    }
>  else
>    g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: instance `%p' has no handler with id `%lu'", "gsignal.c" ":" "1695", instance, handler_id);
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>}
>
>void
>IA__g_signal_handler_unblock (gpointer instance,
>                          gulong handler_id)
>{
>  Handler *handler;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (((IA__g_type_check_instance ((GTypeInstance*) (GTypeInstance*) (instance))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_CHECK_INSTANCE (instance)"); return; }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (handler_id > 0) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "handler_id > 0"); return; }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  handler = handler_lookup (instance, handler_id, ((void *)0));
>  if (handler)
>    {
>      if (handler->block_count)
>        handler->block_count -= 1;
>      else
>        g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "gsignal.c" ":" "1715" ": handler `%lu' of instance `%p' is not blocked", handler_id, instance);
>    }
>  else
>    g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: instance `%p' has no handler with id `%lu'", "gsignal.c" ":" "1718", instance, handler_id);
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>}
>
>void
>IA__g_signal_handler_disconnect (gpointer instance,
>                             gulong handler_id)
>{
>  Handler *handler;
>  guint signal_id;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (((IA__g_type_check_instance ((GTypeInstance*) (GTypeInstance*) (instance))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_CHECK_INSTANCE (instance)"); return; }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (handler_id > 0) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "handler_id > 0"); return; }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  handler = handler_lookup (instance, handler_id, &signal_id);
>  if (handler)
>    {
>      handler->sequential_number = 0;
>      handler->block_count = 1;
>      handler_unref_R (signal_id, instance, handler);
>    }
>  else
>    g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: instance `%p' has no handler with id `%lu'", "gsignal.c" ":" "1741", instance, handler_id);
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>}
>
>gboolean
>IA__g_signal_handler_is_connected (gpointer instance,
>          gulong handler_id)
>{
>  Handler *handler;
>  gboolean connected;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (((IA__g_type_check_instance ((GTypeInstance*) (GTypeInstance*) (instance))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_CHECK_INSTANCE (instance)"); return ((0)); }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  handler = handler_lookup (instance, handler_id, ((void *)0));
>  connected = handler != ((void *)0);
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>
>  return connected;
>}
>
>void
>IA__g_signal_handlers_destroy (gpointer instance)
>{
>  GBSearchArray *hlbsa;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (((IA__g_type_check_instance ((GTypeInstance*) (GTypeInstance*) (instance))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_CHECK_INSTANCE (instance)"); return; }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  hlbsa = g_hash_table_lookup (g_handler_list_bsa_ht, instance);
>  if (hlbsa)
>    {
>      guint i;
>
>
>      g_hash_table_remove (g_handler_list_bsa_ht, instance);
>
>      for (i = 0; i < hlbsa->n_nodes; i++)
>        {
>          HandlerList *hlist = g_bsearch_array_get_nth (hlbsa, &g_signal_hlbsa_bconfig, i);
>          Handler *handler = hlist->handlers;
>
>          while (handler)
>            {
>              Handler *tmp = handler;
>
>              handler = tmp->next;
>              tmp->block_count = 1;
>
>              tmp->next = ((void *)0);
>              tmp->prev = tmp;
>              if (tmp->sequential_number)
>  {
>    tmp->sequential_number = 0;
>    handler_unref_R (0, ((void *)0), tmp);
>  }
>            }
>        }
>      g_bsearch_array_free (hlbsa, &g_signal_hlbsa_bconfig);
>    }
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>}
>
>gulong
>IA__g_signal_handler_find (gpointer instance,
>                       GSignalMatchType mask,
>                       guint signal_id,
>         GQuark detail,
>                       GClosure *closure,
>                       gpointer func,
>                       gpointer data)
>{
>  gulong handler_seq_no = 0;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (((IA__g_type_check_instance ((GTypeInstance*) (GTypeInstance*) (instance))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_CHECK_INSTANCE (instance)"); return (0); }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if ((mask & ~0x3f) == 0) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "(mask & ~G_SIGNAL_MATCH_MASK) == 0"); return (0); }; });
>
>  if (mask & 0x3f)
>    {
>      HandlerMatch *mlist;
>
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      mlist = handlers_find (instance, mask, signal_id, detail, closure, func, data, (!(0)));
>      if (mlist)
> {
>   handler_seq_no = mlist->handler->sequential_number;
>   handler_match_free1_R (mlist, instance);
> }
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>    }
>
>  return handler_seq_no;
>}
>
>static guint
>signal_handlers_foreach_matched_R (gpointer instance,
>       GSignalMatchType mask,
>       guint signal_id,
>       GQuark detail,
>       GClosure *closure,
>       gpointer func,
>       gpointer data,
>       void (*callback) (gpointer instance,
>              gulong handler_seq_no))
>{
>  HandlerMatch *mlist;
>  guint n_handlers = 0;
>
>  mlist = handlers_find (instance, mask, signal_id, detail, closure, func, data, (0));
>  while (mlist)
>    {
>      n_handlers++;
>      if (mlist->handler->sequential_number)
> {
>   ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>   callback (instance, mlist->handler->sequential_number);
>   ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
> }
>      mlist = handler_match_free1_R (mlist, instance);
>    }
>
>  return n_handlers;
>}
>
>guint
>IA__g_signal_handlers_block_matched (gpointer instance,
>     GSignalMatchType mask,
>     guint signal_id,
>     GQuark detail,
>     GClosure *closure,
>     gpointer func,
>     gpointer data)
>{
>  guint n_handlers = 0;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (((IA__g_type_check_instance ((GTypeInstance*) (GTypeInstance*) (instance))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_CHECK_INSTANCE (instance)"); return (0); }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if ((mask & ~0x3f) == 0) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "(mask & ~G_SIGNAL_MATCH_MASK) == 0"); return (0); }; });
>
>  if (mask & (G_SIGNAL_MATCH_CLOSURE | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA))
>    {
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      n_handlers = signal_handlers_foreach_matched_R (instance, mask, signal_id, detail,
>            closure, func, data,
>            IA__g_signal_handler_block);
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>    }
>
>  return n_handlers;
>}
>
>guint
>IA__g_signal_handlers_unblock_matched (gpointer instance,
>       GSignalMatchType mask,
>       guint signal_id,
>       GQuark detail,
>       GClosure *closure,
>       gpointer func,
>       gpointer data)
>{
>  guint n_handlers = 0;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (((IA__g_type_check_instance ((GTypeInstance*) (GTypeInstance*) (instance))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_CHECK_INSTANCE (instance)"); return (0); }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if ((mask & ~0x3f) == 0) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "(mask & ~G_SIGNAL_MATCH_MASK) == 0"); return (0); }; });
>
>  if (mask & (G_SIGNAL_MATCH_CLOSURE | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA))
>    {
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      n_handlers = signal_handlers_foreach_matched_R (instance, mask, signal_id, detail,
>            closure, func, data,
>            IA__g_signal_handler_unblock);
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>    }
>
>  return n_handlers;
>}
>
>guint
>IA__g_signal_handlers_disconnect_matched (gpointer instance,
>          GSignalMatchType mask,
>          guint signal_id,
>          GQuark detail,
>          GClosure *closure,
>          gpointer func,
>          gpointer data)
>{
>  guint n_handlers = 0;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (((IA__g_type_check_instance ((GTypeInstance*) (GTypeInstance*) (instance))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_CHECK_INSTANCE (instance)"); return (0); }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if ((mask & ~0x3f) == 0) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "(mask & ~G_SIGNAL_MATCH_MASK) == 0"); return (0); }; });
>
>  if (mask & (G_SIGNAL_MATCH_CLOSURE | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA))
>    {
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      n_handlers = signal_handlers_foreach_matched_R (instance, mask, signal_id, detail,
>            closure, func, data,
>            IA__g_signal_handler_disconnect);
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>    }
>
>  return n_handlers;
>}
>
>gboolean
>IA__g_signal_has_handler_pending (gpointer instance,
>         guint signal_id,
>         GQuark detail,
>         gboolean may_be_blocked)
>{
>  HandlerMatch *mlist;
>  gboolean has_pending;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (((IA__g_type_check_instance ((GTypeInstance*) (GTypeInstance*) (instance))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_CHECK_INSTANCE (instance)"); return ((0)); }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (signal_id > 0) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "signal_id > 0"); return ((0)); }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  if (detail)
>    {
>      SignalNode *node = LOOKUP_SIGNAL_NODE (signal_id);
>
>      if (!(node->flags & G_SIGNAL_DETAILED))
> {
>   g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal id `%u' does not support detail (%u)", "gsignal.c" ":" "1962", signal_id, detail);
>   ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>   return (0);
> }
>    }
>  mlist = handlers_find (instance,
>    (G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | (may_be_blocked ? 0 : G_SIGNAL_MATCH_UNBLOCKED)),
>    signal_id, detail, ((void *)0), ((void *)0), ((void *)0), (!(0)));
>  if (mlist)
>    {
>      has_pending = (!(0));
>      handler_match_free1_R (mlist, instance);
>    }
>  else
>    has_pending = (0);
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>
>  return has_pending;
>}
>
>static inline gboolean
>signal_check_skip_emission (SignalNode *node,
>       gpointer instance,
>       GQuark detail)
>{
>  HandlerList *hlist;
>
>
>  if (!node->test_class_offset)
>    return (0);
>
>
>  if (node->emission_hooks && node->emission_hooks->hooks)
>    return (0);
>
>
>  if (node->test_class_offset != (1))
>    {
>      GTypeClass *class = (((GTypeClass*) (((GTypeInstance*) (instance))->g_class)));
>
>      if ((*(gpointer*) ((gpointer) ((guint8*) ((class)) + (glong) ((node->test_class_offset))))))
> return (0);
>    }
># 2013 "gsignal.c"
>  if (node->flags & G_SIGNAL_NO_RECURSE &&
>      emission_find (g_restart_emissions, node->signal_id, detail, instance))
>    return (0);
>
>
>  hlist = handler_list_lookup (node->signal_id, instance);
>  if (hlist && hlist->handlers)
>    return (0);
>
>
>  return (!(0));
>}
>
>void
>IA__g_signal_emitv (const GValue *instance_and_params,
>  guint signal_id,
>  GQuark detail,
>  GValue *return_value)
>{
>  gpointer instance;
>  SignalNode *node;
>
>
>
>
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (instance_and_params != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "instance_and_params != NULL"); return; }; });
>  instance = IA__g_value_peek_pointer (instance_and_params);
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (((IA__g_type_check_instance ((GTypeInstance*) (GTypeInstance*) (instance))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_CHECK_INSTANCE (instance)"); return; }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (signal_id > 0) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "signal_id > 0"); return; }; });
>
>
>
>
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  node = LOOKUP_SIGNAL_NODE (signal_id);
>  if (!node || !IA__g_type_is_a (((((GTypeClass*) (((GTypeInstance*) (instance))->g_class))->g_type)), node->itype))
>    {
>      g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal id `%u' is invalid for instance `%p'", "gsignal.c" ":" "2052", signal_id, instance);
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      return;
>    }
># 2102 "gsignal.c"
>  if (signal_check_skip_emission (node, instance, detail))
>    {
>
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>
>      return;
>    }
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  signal_emit_unlocked_R (node, detail, instance, return_value, instance_and_params);
>}
>
>void
>IA__g_signal_emit_valist (gpointer instance,
>        guint signal_id,
>        GQuark detail,
>        va_list var_args)
>{
>  GValue *instance_and_params, stack_values[(16)], *free_me = ((void *)0);
>  GType signal_return_type;
>  GValue *param_values;
>  SignalNode *node;
>  guint i, n_params;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (((IA__g_type_check_instance ((GTypeInstance*) (GTypeInstance*) (instance))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_CHECK_INSTANCE (instance)"); return; }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (signal_id > 0) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "signal_id > 0"); return; }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  node = LOOKUP_SIGNAL_NODE (signal_id);
>  if (!node || !IA__g_type_is_a (((((GTypeClass*) (((GTypeInstance*) (instance))->g_class))->g_type)), node->itype))
>    {
>      g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal id `%u' is invalid for instance `%p'", "gsignal.c" ":" "2133", signal_id, instance);
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      return;
>    }
>
>  if (detail && !(node->flags & G_SIGNAL_DETAILED))
>    {
>      g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal id `%u' does not support detail (%u)", "gsignal.c" ":" "2140", signal_id, detail);
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      return;
>    }
>
>
>
>  if (signal_check_skip_emission (node, instance, detail))
>    {
>
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>
>      return;
>    }
>
>  n_params = node->n_params;
>  signal_return_type = node->return_type;
>  if (node->n_params < (16))
>    instance_and_params = stack_values;
>  else
>    {
>      free_me = ((GValue *) g_malloc (((gsize) sizeof (GValue)) * ((gsize) (node->n_params + 1))));
>      instance_and_params = free_me;
>    }
>  param_values = instance_and_params + 1;
>  for (i = 0; i < node->n_params; i++)
>    {
>      gchar *error;
>      GType ptype = node->param_types[i] & ~(((GType) (1 << 0)));
>      gboolean static_scope = node->param_types[i] & (((GType) (1 << 0)));
>
>      param_values[i].g_type = 0;
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      IA__g_value_init (param_values + i, ptype);
>      (void) __extension__ ( { GValue *_value = (param_values + i); guint _flags = (static_scope ? (1 << 27) : 0); GType _value_type = (((GValue*) (_value))->g_type); GTypeValueTable *_vtable = IA__g_type_value_table_peek (_value_type); gchar *_collect_format = _vtable->collect_format; GTypeCValue _cvalues[(8)] = { { 0, }, }; guint _n_values = 0; if (_vtable->value_free) _vtable->value_free (_value); _value->g_type = _value_type; memset (_value->data, 0, sizeof (_value->data)); while (*_collect_format) { GTypeCValue *_cvalue = _cvalues + _n_values++; switch (*_collect_format++) { case G_VALUE_COLLECT_INT: _cvalue->v_int = __builtin_va_arg((var_args),gint); break; case G_VALUE_COLLECT_LONG: _cvalue->v_long = __builtin_va_arg((var_args),glong); break; case G_VALUE_COLLECT_INT64: _cvalue->v_int64 = __builtin_va_arg((var_args),gint64); break; case G_VALUE_COLLECT_DOUBLE: _cvalue->v_double = __builtin_va_arg((var_args),gdouble); break; case G_VALUE_COLLECT_POINTER: _cvalue->v_pointer = __builtin_va_arg((var_args),gpointer); break; default: do { g_assertion_message ("GLib-GObject", "gsignal.c", 2177, ((const char*) (__PRETTY_FUNCTION__)), ((void *)0)); } while (0); } } *(&error) = _vtable->collect_value (_value, _n_values, _cvalues, _flags); } );
>
>
>
>      if (error)
> {
>   g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: %s", "gsignal.c" ":" "2180", error);
>   g_free (error);
>
>
>
>
>   while (i--)
>     IA__g_value_unset (param_values + i);
>
>   g_free (free_me);
>   return;
> }
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>    }
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  instance_and_params->g_type = 0;
>  IA__g_value_init (instance_and_params, ((((GTypeClass*) (((GTypeInstance*) (instance))->g_class))->g_type)));
>  IA__g_value_set_instance (instance_and_params, instance);
>  if (signal_return_type == ((GType) ((1) << (2))))
>    signal_emit_unlocked_R (node, detail, instance, ((void *)0), instance_and_params);
>  else
>    {
>      GValue return_value = { 0, };
>      gchar *error = ((void *)0);
>      GType rtype = signal_return_type & ~(((GType) (1 << 0)));
>      gboolean static_scope = signal_return_type & (((GType) (1 << 0)));
>
>      IA__g_value_init (&return_value, rtype);
>
>      signal_emit_unlocked_R (node, detail, instance, &return_value, instance_and_params);
>
>      (void) __extension__ ( { const GValue *_value = (&return_value); guint _flags = (static_scope ? (1 << 27) : 0); GType _value_type = (((GValue*) (_value))->g_type); GTypeValueTable *_vtable = IA__g_type_value_table_peek (_value_type); gchar *_lcopy_format = _vtable->lcopy_format; GTypeCValue _cvalues[(8)] = { { 0, }, }; guint _n_values = 0; while (*_lcopy_format) { GTypeCValue *_cvalue = _cvalues + _n_values++; switch (*_lcopy_format++) { case G_VALUE_COLLECT_INT: _cvalue->v_int = __builtin_va_arg((var_args),gint); break; case G_VALUE_COLLECT_LONG: _cvalue->v_long = __builtin_va_arg((var_args),glong); break; case G_VALUE_COLLECT_INT64: _cvalue->v_int64 = __builtin_va_arg((var_args),gint64); break; case G_VALUE_COLLECT_DOUBLE: _cvalue->v_double = __builtin_va_arg((var_args),gdouble); break; case G_VALUE_COLLECT_POINTER: _cvalue->v_pointer = __builtin_va_arg((var_args),gpointer); break; default: do { g_assertion_message ("GLib-GObject", "gsignal.c", 2214, ((const char*) (__PRETTY_FUNCTION__)), ((void *)0)); } while (0); } } *(&error) = _vtable->lcopy_value (_value, _n_values, _cvalues, _flags); } );
>
>
>
>      if (!error)
> IA__g_value_unset (&return_value);
>      else
> {
>   g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: %s", "gsignal.c" ":" "2219", error);
>   g_free (error);
>
>
>
>
> }
>    }
>  for (i = 0; i < n_params; i++)
>    IA__g_value_unset (param_values + i);
>  IA__g_value_unset (instance_and_params);
>  if (free_me)
>    g_free (free_me);
>}
>
>void
>IA__g_signal_emit (gpointer instance,
>        guint signal_id,
>        GQuark detail,
>        ...)
>{
>  va_list var_args;
>
>  __builtin_va_start(var_args,detail);
>  IA__g_signal_emit_valist (instance, signal_id, detail, var_args);
>  __builtin_va_end(var_args);
>}
>
>void
>IA__g_signal_emit_by_name (gpointer instance,
>         const gchar *detailed_signal,
>         ...)
>{
>  GQuark detail = 0;
>  guint signal_id;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (((IA__g_type_check_instance ((GTypeInstance*) (GTypeInstance*) (instance))))) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "G_TYPE_CHECK_INSTANCE (instance)"); return; }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (detailed_signal != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "detailed_signal != NULL"); return; }; });
>
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  signal_id = signal_parse_name (detailed_signal, ((((GTypeClass*) (((GTypeInstance*) (instance))->g_class))->g_type)), &detail, (!(0)));
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>
>  if (signal_id)
>    {
>      va_list var_args;
>
>      __builtin_va_start(var_args,detailed_signal);
>      IA__g_signal_emit_valist (instance, signal_id, detail, var_args);
>      __builtin_va_end(var_args);
>    }
>  else
>    g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "%s: signal name `%s' is invalid for instance `%p'", "gsignal.c" ":" "2271", detailed_signal, instance);
>}
>
>static inline gboolean
>accumulate (GSignalInvocationHint *ihint,
>     GValue *return_accu,
>     GValue *handler_return,
>     SignalAccumulator *accumulator)
>{
>  gboolean continue_emission;
>
>  if (!accumulator)
>    return (!(0));
>  g_log ("GLib-GObject", G_LOG_LEVEL_WARNING, "accumulator is %p\n", accumulator);
>  continue_emission = accumulator->func (ihint, return_accu, handler_return, accumulator->data);
>  IA__g_value_reset (handler_return);
>
>  return continue_emission;
>}
>
>static gboolean
>signal_emit_unlocked_R (SignalNode *node,
>   GQuark detail,
>   gpointer instance,
>   GValue *emission_return,
>   const GValue *instance_and_params)
>{
>  SignalAccumulator *accumulator;
>  Emission emission;
>  GClosure *class_closure;
>  HandlerList *hlist;
>  Handler *handler_list = ((void *)0);
>  GValue *return_accu, accu = { 0, };
>  guint signal_id;
>  gulong max_sequential_handler_number;
>  gboolean return_value_altered = (0);
># 2320 "gsignal.c"
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  signal_id = node->signal_id;
>  if (node->flags & G_SIGNAL_NO_RECURSE)
>    {
>      Emission *node = emission_find (g_restart_emissions, signal_id, detail, instance);
>
>      if (node)
> {
>   node->state = EMISSION_RESTART;
>   ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>   return return_value_altered;
> }
>    }
>  accumulator = node->accumulator;
>  if (accumulator)
>    {
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      IA__g_value_init (&accu, node->return_type & ~(((GType) (1 << 0))));
>      return_accu = &accu;
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>    }
>  else
>    return_accu = emission_return;
>  emission.instance = instance;
>  emission.ihint.signal_id = node->signal_id;
>  emission.ihint.detail = detail;
>  emission.ihint.run_type = 0;
>  emission.state = 0;
>  emission.chain_type = ((GType) ((1) << (2)));
>  emission_push ((node->flags & G_SIGNAL_NO_RECURSE) ? &g_restart_emissions : &g_recursive_emissions, &emission);
>  class_closure = signal_lookup_closure (node, instance);
>
> EMIT_RESTART:
>
>  if (handler_list)
>    handler_unref_R (signal_id, instance, handler_list);
>  max_sequential_handler_number = g_handler_sequential_number;
>  hlist = handler_list_lookup (signal_id, instance);
>  handler_list = hlist ? hlist->handlers : ((void *)0);
>  if (handler_list)
>    handler_ref (handler_list);
>
>  emission.ihint.run_type = G_SIGNAL_RUN_FIRST;
>
>  if ((node->flags & G_SIGNAL_RUN_FIRST) && class_closure)
>    {
>      emission.state = EMISSION_RUN;
>
>      emission.chain_type = ((((GTypeClass*) (((GTypeInstance*) (instance))->g_class))->g_type));
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      IA__g_closure_invoke (class_closure,
>   return_accu,
>   node->n_params + 1,
>   instance_and_params,
>   &emission.ihint);
>      if (!accumulate (&emission.ihint, emission_return, &accu, accumulator) &&
>   emission.state == EMISSION_RUN)
> emission.state = EMISSION_STOP;
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      emission.chain_type = ((GType) ((1) << (2)));
>      return_value_altered = (!(0));
>
>      if (emission.state == EMISSION_STOP)
> goto EMIT_CLEANUP;
>      else if (emission.state == EMISSION_RESTART)
> goto EMIT_RESTART;
>    }
>
>  if (node->emission_hooks)
>    {
>      gboolean need_destroy, was_in_call, may_recurse = (!(0));
>      GHook *hook;
>
>      emission.state = EMISSION_HOOK;
>      hook = g_hook_first_valid (node->emission_hooks, may_recurse);
>      while (hook)
> {
>   SignalHook *signal_hook = ((SignalHook*) (hook));
>
>   if (!signal_hook->detail || signal_hook->detail == detail)
>     {
>       GSignalEmissionHook hook_func = (GSignalEmissionHook) hook->func;
>
>       was_in_call = (((((GHook*) (hook))->flags) & G_HOOK_FLAG_IN_CALL) != 0);
>       hook->flags |= G_HOOK_FLAG_IN_CALL;
>              ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>       need_destroy = !hook_func (&emission.ihint, node->n_params + 1, instance_and_params, hook->data);
>       ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>       if (!was_in_call)
>  hook->flags &= ~G_HOOK_FLAG_IN_CALL;
>       if (need_destroy)
>  g_hook_destroy_link (node->emission_hooks, hook);
>     }
>   hook = g_hook_next_valid (node->emission_hooks, hook, may_recurse);
> }
>
>      if (emission.state == EMISSION_RESTART)
> goto EMIT_RESTART;
>    }
>
>  if (handler_list)
>    {
>      Handler *handler = handler_list;
>
>      emission.state = EMISSION_RUN;
>      handler_ref (handler);
>      do
> {
>   Handler *tmp;
>
>   if (handler->after)
>     {
>       handler_unref_R (signal_id, instance, handler_list);
>       handler_list = handler;
>       break;
>     }
>   else if (!handler->block_count && (!handler->detail || handler->detail == detail) &&
>     handler->sequential_number < max_sequential_handler_number)
>     {
>       ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>       IA__g_closure_invoke (handler->closure,
>    return_accu,
>    node->n_params + 1,
>    instance_and_params,
>    &emission.ihint);
>       if (!accumulate (&emission.ihint, emission_return, &accu, accumulator) &&
>    emission.state == EMISSION_RUN)
>  emission.state = EMISSION_STOP;
>       ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>       return_value_altered = (!(0));
>
>       tmp = emission.state == EMISSION_RUN ? handler->next : ((void *)0);
>     }
>   else
>     tmp = handler->next;
>
>   if (tmp)
>     handler_ref (tmp);
>   handler_unref_R (signal_id, instance, handler_list);
>   handler_list = handler;
>   handler = tmp;
> }
>      while (handler);
>
>      if (emission.state == EMISSION_STOP)
> goto EMIT_CLEANUP;
>      else if (emission.state == EMISSION_RESTART)
> goto EMIT_RESTART;
>    }
>
>  emission.ihint.run_type = G_SIGNAL_RUN_LAST;
>
>  if ((node->flags & G_SIGNAL_RUN_LAST) && class_closure)
>    {
>      emission.state = EMISSION_RUN;
>
>      emission.chain_type = ((((GTypeClass*) (((GTypeInstance*) (instance))->g_class))->g_type));
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      IA__g_closure_invoke (class_closure,
>   return_accu,
>   node->n_params + 1,
>   instance_and_params,
>   &emission.ihint);
>      if (!accumulate (&emission.ihint, emission_return, &accu, accumulator) &&
>   emission.state == EMISSION_RUN)
> emission.state = EMISSION_STOP;
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      emission.chain_type = ((GType) ((1) << (2)));
>      return_value_altered = (!(0));
>
>      if (emission.state == EMISSION_STOP)
> goto EMIT_CLEANUP;
>      else if (emission.state == EMISSION_RESTART)
> goto EMIT_RESTART;
>    }
>
>  if (handler_list)
>    {
>      Handler *handler = handler_list;
>
>      emission.state = EMISSION_RUN;
>      handler_ref (handler);
>      do
> {
>   Handler *tmp;
>
>   if (handler->after && !handler->block_count && (!handler->detail || handler->detail == detail) &&
>       handler->sequential_number < max_sequential_handler_number)
>     {
>       ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>       IA__g_closure_invoke (handler->closure,
>    return_accu,
>    node->n_params + 1,
>    instance_and_params,
>    &emission.ihint);
>       if (!accumulate (&emission.ihint, emission_return, &accu, accumulator) &&
>    emission.state == EMISSION_RUN)
>  emission.state = EMISSION_STOP;
>       ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>       return_value_altered = (!(0));
>
>       tmp = emission.state == EMISSION_RUN ? handler->next : ((void *)0);
>     }
>   else
>     tmp = handler->next;
>
>   if (tmp)
>     handler_ref (tmp);
>   handler_unref_R (signal_id, instance, handler);
>   handler = tmp;
> }
>      while (handler);
>
>      if (emission.state == EMISSION_STOP)
> goto EMIT_CLEANUP;
>      else if (emission.state == EMISSION_RESTART)
> goto EMIT_RESTART;
>    }
>
> EMIT_CLEANUP:
>
>  emission.ihint.run_type = G_SIGNAL_RUN_CLEANUP;
>
>  if ((node->flags & G_SIGNAL_RUN_CLEANUP) && class_closure)
>    {
>      gboolean need_unset = (0);
>
>      emission.state = EMISSION_STOP;
>
>      emission.chain_type = ((((GTypeClass*) (((GTypeInstance*) (instance))->g_class))->g_type));
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      if (node->return_type != ((GType) ((1) << (2))) && !accumulator)
> {
>   IA__g_value_init (&accu, node->return_type & ~(((GType) (1 << 0))));
>   need_unset = (!(0));
> }
>      IA__g_closure_invoke (class_closure,
>   node->return_type != ((GType) ((1) << (2))) ? &accu : ((void *)0),
>   node->n_params + 1,
>   instance_and_params,
>   &emission.ihint);
>      if (need_unset)
> IA__g_value_unset (&accu);
>      ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_lock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>      emission.chain_type = ((GType) ((1) << (2)));
>
>      if (emission.state == EMISSION_RESTART)
> goto EMIT_RESTART;
>    }
>
>  if (handler_list)
>    handler_unref_R (signal_id, instance, handler_list);
>
>  emission_pop ((node->flags & G_SIGNAL_NO_RECURSE) ? &g_restart_emissions : &g_recursive_emissions, &emission);
>  ((g_threads_got_initialized) ? (*g_thread_functions_for_glib_use . mutex_unlock) ((g_thread_use_default_impl ? ((GMutex*) (void*) ((&g__g_signal_mutex_lock)->static_mutex.pad)) : (g_atomic_pointer_get ((gpointer*)(void*)&((&g__g_signal_mutex_lock)->runtime_mutex)) ? *(&((&g__g_signal_mutex_lock)->runtime_mutex)) : g_static_mutex_get_mutex_impl (&((&g__g_signal_mutex_lock)->runtime_mutex))))) : ((void)0));
>  if (accumulator)
>    IA__g_value_unset (&accu);
>
>  return return_value_altered;
>}
>
>static const gchar*
>type_debug_name (GType type)
>{
>  if (type)
>    {
>      const char *name = IA__g_type_name (type & ~(((GType) (1 << 0))));
>      return name ? name : "<unknown>";
>    }
>  else
>    return "<invalid>";
>}
>
>gboolean
>IA__g_signal_accumulator_true_handled (GSignalInvocationHint *ihint,
>       GValue *return_accu,
>       const GValue *handler_return,
>       gpointer dummy)
>{
>  gboolean continue_emission;
>  gboolean signal_handled;
>
>  signal_handled = IA__g_value_get_boolean (handler_return);
>  IA__g_value_set_boolean (return_accu, signal_handled);
>  continue_emission = !signal_handled;
>
>  return continue_emission;
>}
>
>
># 1 "gmarshal.c" 1
># 49 "gmarshal.c"
>void
>IA__g_cclosure_marshal_VOID__VOID (GClosure *closure,
>                               GValue *return_value __attribute__((__unused__)),
>                               guint n_param_values,
>                               const GValue *param_values,
>                               gpointer invocation_hint __attribute__((__unused__)),
>                               gpointer marshal_data)
>{
>  typedef void (*GMarshalFunc_VOID__VOID) (gpointer data1,
>                                           gpointer data2);
>  register GMarshalFunc_VOID__VOID callback;
>  register GCClosure *cc = (GCClosure*) closure;
>  register gpointer data1, data2;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_param_values == 1) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_param_values == 1"); return; }; });
>
>  if ((((GClosure*) (closure))->derivative_flag))
>    {
>      data1 = closure->data;
>      data2 = IA__g_value_peek_pointer (param_values + 0);
>    }
>  else
>    {
>      data1 = IA__g_value_peek_pointer (param_values + 0);
>      data2 = closure->data;
>    }
>  callback = (GMarshalFunc_VOID__VOID) (marshal_data ? marshal_data : cc->callback);
>
>  callback (data1,
>            data2);
>}
>
>
>void
>IA__g_cclosure_marshal_VOID__BOOLEAN (GClosure *closure,
>                                  GValue *return_value __attribute__((__unused__)),
>                                  guint n_param_values,
>                                  const GValue *param_values,
>                                  gpointer invocation_hint __attribute__((__unused__)),
>                                  gpointer marshal_data)
>{
>  typedef void (*GMarshalFunc_VOID__BOOLEAN) (gpointer data1,
>                                              gboolean arg_1,
>                                              gpointer data2);
>  register GMarshalFunc_VOID__BOOLEAN callback;
>  register GCClosure *cc = (GCClosure*) closure;
>  register gpointer data1, data2;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_param_values == 2) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_param_values == 2"); return; }; });
>
>  if ((((GClosure*) (closure))->derivative_flag))
>    {
>      data1 = closure->data;
>      data2 = IA__g_value_peek_pointer (param_values + 0);
>    }
>  else
>    {
>      data1 = IA__g_value_peek_pointer (param_values + 0);
>      data2 = closure->data;
>    }
>  callback = (GMarshalFunc_VOID__BOOLEAN) (marshal_data ? marshal_data : cc->callback);
>
>  callback (data1,
>            (param_values + 1)->data[0].v_int,
>            data2);
>}
>
>
>void
>IA__g_cclosure_marshal_VOID__CHAR (GClosure *closure,
>                               GValue *return_value __attribute__((__unused__)),
>                               guint n_param_values,
>                               const GValue *param_values,
>                               gpointer invocation_hint __attribute__((__unused__)),
>                               gpointer marshal_data)
>{
>  typedef void (*GMarshalFunc_VOID__CHAR) (gpointer data1,
>                                           gchar arg_1,
>                                           gpointer data2);
>  register GMarshalFunc_VOID__CHAR callback;
>  register GCClosure *cc = (GCClosure*) closure;
>  register gpointer data1, data2;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_param_values == 2) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_param_values == 2"); return; }; });
>
>  if ((((GClosure*) (closure))->derivative_flag))
>    {
>      data1 = closure->data;
>      data2 = IA__g_value_peek_pointer (param_values + 0);
>    }
>  else
>    {
>      data1 = IA__g_value_peek_pointer (param_values + 0);
>      data2 = closure->data;
>    }
>  callback = (GMarshalFunc_VOID__CHAR) (marshal_data ? marshal_data : cc->callback);
>
>  callback (data1,
>            (param_values + 1)->data[0].v_int,
>            data2);
>}
>
>
>void
>IA__g_cclosure_marshal_VOID__UCHAR (GClosure *closure,
>                                GValue *return_value __attribute__((__unused__)),
>                                guint n_param_values,
>                                const GValue *param_values,
>                                gpointer invocation_hint __attribute__((__unused__)),
>                                gpointer marshal_data)
>{
>  typedef void (*GMarshalFunc_VOID__UCHAR) (gpointer data1,
>                                            guchar arg_1,
>                                            gpointer data2);
>  register GMarshalFunc_VOID__UCHAR callback;
>  register GCClosure *cc = (GCClosure*) closure;
>  register gpointer data1, data2;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_param_values == 2) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_param_values == 2"); return; }; });
>
>  if ((((GClosure*) (closure))->derivative_flag))
>    {
>      data1 = closure->data;
>      data2 = IA__g_value_peek_pointer (param_values + 0);
>    }
>  else
>    {
>      data1 = IA__g_value_peek_pointer (param_values + 0);
>      data2 = closure->data;
>    }
>  callback = (GMarshalFunc_VOID__UCHAR) (marshal_data ? marshal_data : cc->callback);
>
>  callback (data1,
>            (param_values + 1)->data[0].v_uint,
>            data2);
>}
>
>
>void
>IA__g_cclosure_marshal_VOID__INT (GClosure *closure,
>                              GValue *return_value __attribute__((__unused__)),
>                              guint n_param_values,
>                              const GValue *param_values,
>                              gpointer invocation_hint __attribute__((__unused__)),
>                              gpointer marshal_data)
>{
>  typedef void (*GMarshalFunc_VOID__INT) (gpointer data1,
>                                          gint arg_1,
>                                          gpointer data2);
>  register GMarshalFunc_VOID__INT callback;
>  register GCClosure *cc = (GCClosure*) closure;
>  register gpointer data1, data2;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_param_values == 2) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_param_values == 2"); return; }; });
>
>  if ((((GClosure*) (closure))->derivative_flag))
>    {
>      data1 = closure->data;
>      data2 = IA__g_value_peek_pointer (param_values + 0);
>    }
>  else
>    {
>      data1 = IA__g_value_peek_pointer (param_values + 0);
>      data2 = closure->data;
>    }
>  callback = (GMarshalFunc_VOID__INT) (marshal_data ? marshal_data : cc->callback);
>
>  callback (data1,
>            (param_values + 1)->data[0].v_int,
>            data2);
>}
>
>
>void
>IA__g_cclosure_marshal_VOID__UINT (GClosure *closure,
>                               GValue *return_value __attribute__((__unused__)),
>                               guint n_param_values,
>                               const GValue *param_values,
>                               gpointer invocation_hint __attribute__((__unused__)),
>                               gpointer marshal_data)
>{
>  typedef void (*GMarshalFunc_VOID__UINT) (gpointer data1,
>                                           guint arg_1,
>                                           gpointer data2);
>  register GMarshalFunc_VOID__UINT callback;
>  register GCClosure *cc = (GCClosure*) closure;
>  register gpointer data1, data2;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_param_values == 2) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_param_values == 2"); return; }; });
>
>  if ((((GClosure*) (closure))->derivative_flag))
>    {
>      data1 = closure->data;
>      data2 = IA__g_value_peek_pointer (param_values + 0);
>    }
>  else
>    {
>      data1 = IA__g_value_peek_pointer (param_values + 0);
>      data2 = closure->data;
>    }
>  callback = (GMarshalFunc_VOID__UINT) (marshal_data ? marshal_data : cc->callback);
>
>  callback (data1,
>            (param_values + 1)->data[0].v_uint,
>            data2);
>}
>
>
>void
>IA__g_cclosure_marshal_VOID__LONG (GClosure *closure,
>                               GValue *return_value __attribute__((__unused__)),
>                               guint n_param_values,
>                               const GValue *param_values,
>                               gpointer invocation_hint __attribute__((__unused__)),
>                               gpointer marshal_data)
>{
>  typedef void (*GMarshalFunc_VOID__LONG) (gpointer data1,
>                                           glong arg_1,
>                                           gpointer data2);
>  register GMarshalFunc_VOID__LONG callback;
>  register GCClosure *cc = (GCClosure*) closure;
>  register gpointer data1, data2;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_param_values == 2) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_param_values == 2"); return; }; });
>
>  if ((((GClosure*) (closure))->derivative_flag))
>    {
>      data1 = closure->data;
>      data2 = IA__g_value_peek_pointer (param_values + 0);
>    }
>  else
>    {
>      data1 = IA__g_value_peek_pointer (param_values + 0);
>      data2 = closure->data;
>    }
>  callback = (GMarshalFunc_VOID__LONG) (marshal_data ? marshal_data : cc->callback);
>
>  callback (data1,
>            (param_values + 1)->data[0].v_long,
>            data2);
>}
>
>
>void
>IA__g_cclosure_marshal_VOID__ULONG (GClosure *closure,
>                                GValue *return_value __attribute__((__unused__)),
>                                guint n_param_values,
>                                const GValue *param_values,
>                                gpointer invocation_hint __attribute__((__unused__)),
>                                gpointer marshal_data)
>{
>  typedef void (*GMarshalFunc_VOID__ULONG) (gpointer data1,
>                                            gulong arg_1,
>                                            gpointer data2);
>  register GMarshalFunc_VOID__ULONG callback;
>  register GCClosure *cc = (GCClosure*) closure;
>  register gpointer data1, data2;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_param_values == 2) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_param_values == 2"); return; }; });
>
>  if ((((GClosure*) (closure))->derivative_flag))
>    {
>      data1 = closure->data;
>      data2 = IA__g_value_peek_pointer (param_values + 0);
>    }
>  else
>    {
>      data1 = IA__g_value_peek_pointer (param_values + 0);
>      data2 = closure->data;
>    }
>  callback = (GMarshalFunc_VOID__ULONG) (marshal_data ? marshal_data : cc->callback);
>
>  callback (data1,
>            (param_values + 1)->data[0].v_ulong,
>            data2);
>}
>
>
>void
>IA__g_cclosure_marshal_VOID__ENUM (GClosure *closure,
>                               GValue *return_value __attribute__((__unused__)),
>                               guint n_param_values,
>                               const GValue *param_values,
>                               gpointer invocation_hint __attribute__((__unused__)),
>                               gpointer marshal_data)
>{
>  typedef void (*GMarshalFunc_VOID__ENUM) (gpointer data1,
>                                           gint arg_1,
>                                           gpointer data2);
>  register GMarshalFunc_VOID__ENUM callback;
>  register GCClosure *cc = (GCClosure*) closure;
>  register gpointer data1, data2;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_param_values == 2) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_param_values == 2"); return; }; });
>
>  if ((((GClosure*) (closure))->derivative_flag))
>    {
>      data1 = closure->data;
>      data2 = IA__g_value_peek_pointer (param_values + 0);
>    }
>  else
>    {
>      data1 = IA__g_value_peek_pointer (param_values + 0);
>      data2 = closure->data;
>    }
>  callback = (GMarshalFunc_VOID__ENUM) (marshal_data ? marshal_data : cc->callback);
>
>  callback (data1,
>            (param_values + 1)->data[0].v_long,
>            data2);
>}
>
>
>void
>IA__g_cclosure_marshal_VOID__FLAGS (GClosure *closure,
>                                GValue *return_value __attribute__((__unused__)),
>                                guint n_param_values,
>                                const GValue *param_values,
>                                gpointer invocation_hint __attribute__((__unused__)),
>                                gpointer marshal_data)
>{
>  typedef void (*GMarshalFunc_VOID__FLAGS) (gpointer data1,
>                                            guint arg_1,
>                                            gpointer data2);
>  register GMarshalFunc_VOID__FLAGS callback;
>  register GCClosure *cc = (GCClosure*) closure;
>  register gpointer data1, data2;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_param_values == 2) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_param_values == 2"); return; }; });
>
>  if ((((GClosure*) (closure))->derivative_flag))
>    {
>      data1 = closure->data;
>      data2 = IA__g_value_peek_pointer (param_values + 0);
>    }
>  else
>    {
>      data1 = IA__g_value_peek_pointer (param_values + 0);
>      data2 = closure->data;
>    }
>  callback = (GMarshalFunc_VOID__FLAGS) (marshal_data ? marshal_data : cc->callback);
>
>  callback (data1,
>            (param_values + 1)->data[0].v_ulong,
>            data2);
>}
>
>
>void
>IA__g_cclosure_marshal_VOID__FLOAT (GClosure *closure,
>                                GValue *return_value __attribute__((__unused__)),
>                                guint n_param_values,
>                                const GValue *param_values,
>                                gpointer invocation_hint __attribute__((__unused__)),
>                                gpointer marshal_data)
>{
>  typedef void (*GMarshalFunc_VOID__FLOAT) (gpointer data1,
>                                            gfloat arg_1,
>                                            gpointer data2);
>  register GMarshalFunc_VOID__FLOAT callback;
>  register GCClosure *cc = (GCClosure*) closure;
>  register gpointer data1, data2;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_param_values == 2) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_param_values == 2"); return; }; });
>
>  if ((((GClosure*) (closure))->derivative_flag))
>    {
>      data1 = closure->data;
>      data2 = IA__g_value_peek_pointer (param_values + 0);
>    }
>  else
>    {
>      data1 = IA__g_value_peek_pointer (param_values + 0);
>      data2 = closure->data;
>    }
>  callback = (GMarshalFunc_VOID__FLOAT) (marshal_data ? marshal_data : cc->callback);
>
>  callback (data1,
>            (param_values + 1)->data[0].v_float,
>            data2);
>}
>
>
>void
>IA__g_cclosure_marshal_VOID__DOUBLE (GClosure *closure,
>                                 GValue *return_value __attribute__((__unused__)),
>                                 guint n_param_values,
>                                 const GValue *param_values,
>                                 gpointer invocation_hint __attribute__((__unused__)),
>                                 gpointer marshal_data)
>{
>  typedef void (*GMarshalFunc_VOID__DOUBLE) (gpointer data1,
>                                             gdouble arg_1,
>                                             gpointer data2);
>  register GMarshalFunc_VOID__DOUBLE callback;
>  register GCClosure *cc = (GCClosure*) closure;
>  register gpointer data1, data2;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_param_values == 2) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_param_values == 2"); return; }; });
>
>  if ((((GClosure*) (closure))->derivative_flag))
>    {
>      data1 = closure->data;
>      data2 = IA__g_value_peek_pointer (param_values + 0);
>    }
>  else
>    {
>      data1 = IA__g_value_peek_pointer (param_values + 0);
>      data2 = closure->data;
>    }
>  callback = (GMarshalFunc_VOID__DOUBLE) (marshal_data ? marshal_data : cc->callback);
>
>  callback (data1,
>            (param_values + 1)->data[0].v_double,
>            data2);
>}
>
>
>void
>IA__g_cclosure_marshal_VOID__STRING (GClosure *closure,
>                                 GValue *return_value __attribute__((__unused__)),
>                                 guint n_param_values,
>                                 const GValue *param_values,
>                                 gpointer invocation_hint __attribute__((__unused__)),
>                                 gpointer marshal_data)
>{
>  typedef void (*GMarshalFunc_VOID__STRING) (gpointer data1,
>                                             gpointer arg_1,
>                                             gpointer data2);
>  register GMarshalFunc_VOID__STRING callback;
>  register GCClosure *cc = (GCClosure*) closure;
>  register gpointer data1, data2;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_param_values == 2) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_param_values == 2"); return; }; });
>
>  if ((((GClosure*) (closure))->derivative_flag))
>    {
>      data1 = closure->data;
>      data2 = IA__g_value_peek_pointer (param_values + 0);
>    }
>  else
>    {
>      data1 = IA__g_value_peek_pointer (param_values + 0);
>      data2 = closure->data;
>    }
>  callback = (GMarshalFunc_VOID__STRING) (marshal_data ? marshal_data : cc->callback);
>
>  callback (data1,
>            (param_values + 1)->data[0].v_pointer,
>            data2);
>}
>
>
>void
>IA__g_cclosure_marshal_VOID__PARAM (GClosure *closure,
>                                GValue *return_value __attribute__((__unused__)),
>                                guint n_param_values,
>                                const GValue *param_values,
>                                gpointer invocation_hint __attribute__((__unused__)),
>                                gpointer marshal_data)
>{
>  typedef void (*GMarshalFunc_VOID__PARAM) (gpointer data1,
>                                            gpointer arg_1,
>                                            gpointer data2);
>  register GMarshalFunc_VOID__PARAM callback;
>  register GCClosure *cc = (GCClosure*) closure;
>  register gpointer data1, data2;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_param_values == 2) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_param_values == 2"); return; }; });
>
>  if ((((GClosure*) (closure))->derivative_flag))
>    {
>      data1 = closure->data;
>      data2 = IA__g_value_peek_pointer (param_values + 0);
>    }
>  else
>    {
>      data1 = IA__g_value_peek_pointer (param_values + 0);
>      data2 = closure->data;
>    }
>  callback = (GMarshalFunc_VOID__PARAM) (marshal_data ? marshal_data : cc->callback);
>
>  callback (data1,
>            (param_values + 1)->data[0].v_pointer,
>            data2);
>}
>
>
>void
>IA__g_cclosure_marshal_VOID__BOXED (GClosure *closure,
>                                GValue *return_value __attribute__((__unused__)),
>                                guint n_param_values,
>                                const GValue *param_values,
>                                gpointer invocation_hint __attribute__((__unused__)),
>                                gpointer marshal_data)
>{
>  typedef void (*GMarshalFunc_VOID__BOXED) (gpointer data1,
>                                            gpointer arg_1,
>                                            gpointer data2);
>  register GMarshalFunc_VOID__BOXED callback;
>  register GCClosure *cc = (GCClosure*) closure;
>  register gpointer data1, data2;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_param_values == 2) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_param_values == 2"); return; }; });
>
>  if ((((GClosure*) (closure))->derivative_flag))
>    {
>      data1 = closure->data;
>      data2 = IA__g_value_peek_pointer (param_values + 0);
>    }
>  else
>    {
>      data1 = IA__g_value_peek_pointer (param_values + 0);
>      data2 = closure->data;
>    }
>  callback = (GMarshalFunc_VOID__BOXED) (marshal_data ? marshal_data : cc->callback);
>
>  callback (data1,
>            (param_values + 1)->data[0].v_pointer,
>            data2);
>}
>
>
>void
>IA__g_cclosure_marshal_VOID__POINTER (GClosure *closure,
>                                  GValue *return_value __attribute__((__unused__)),
>                                  guint n_param_values,
>                                  const GValue *param_values,
>                                  gpointer invocation_hint __attribute__((__unused__)),
>                                  gpointer marshal_data)
>{
>  typedef void (*GMarshalFunc_VOID__POINTER) (gpointer data1,
>                                              gpointer arg_1,
>                                              gpointer data2);
>  register GMarshalFunc_VOID__POINTER callback;
>  register GCClosure *cc = (GCClosure*) closure;
>  register gpointer data1, data2;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_param_values == 2) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_param_values == 2"); return; }; });
>
>  if ((((GClosure*) (closure))->derivative_flag))
>    {
>      data1 = closure->data;
>      data2 = IA__g_value_peek_pointer (param_values + 0);
>    }
>  else
>    {
>      data1 = IA__g_value_peek_pointer (param_values + 0);
>      data2 = closure->data;
>    }
>  callback = (GMarshalFunc_VOID__POINTER) (marshal_data ? marshal_data : cc->callback);
>
>  callback (data1,
>            (param_values + 1)->data[0].v_pointer,
>            data2);
>}
>
>
>void
>IA__g_cclosure_marshal_VOID__OBJECT (GClosure *closure,
>                                 GValue *return_value __attribute__((__unused__)),
>                                 guint n_param_values,
>                                 const GValue *param_values,
>                                 gpointer invocation_hint __attribute__((__unused__)),
>                                 gpointer marshal_data)
>{
>  typedef void (*GMarshalFunc_VOID__OBJECT) (gpointer data1,
>                                             gpointer arg_1,
>                                             gpointer data2);
>  register GMarshalFunc_VOID__OBJECT callback;
>  register GCClosure *cc = (GCClosure*) closure;
>  register gpointer data1, data2;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_param_values == 2) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_param_values == 2"); return; }; });
>
>  if ((((GClosure*) (closure))->derivative_flag))
>    {
>      data1 = closure->data;
>      data2 = IA__g_value_peek_pointer (param_values + 0);
>    }
>  else
>    {
>      data1 = IA__g_value_peek_pointer (param_values + 0);
>      data2 = closure->data;
>    }
>  callback = (GMarshalFunc_VOID__OBJECT) (marshal_data ? marshal_data : cc->callback);
>
>  callback (data1,
>            (param_values + 1)->data[0].v_pointer,
>            data2);
>}
>
>
>void
>IA__g_cclosure_marshal_VOID__UINT_POINTER (GClosure *closure,
>                                       GValue *return_value __attribute__((__unused__)),
>                                       guint n_param_values,
>                                       const GValue *param_values,
>                                       gpointer invocation_hint __attribute__((__unused__)),
>                                       gpointer marshal_data)
>{
>  typedef void (*GMarshalFunc_VOID__UINT_POINTER) (gpointer data1,
>                                                   guint arg_1,
>                                                   gpointer arg_2,
>                                                   gpointer data2);
>  register GMarshalFunc_VOID__UINT_POINTER callback;
>  register GCClosure *cc = (GCClosure*) closure;
>  register gpointer data1, data2;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_param_values == 3) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_param_values == 3"); return; }; });
>
>  if ((((GClosure*) (closure))->derivative_flag))
>    {
>      data1 = closure->data;
>      data2 = IA__g_value_peek_pointer (param_values + 0);
>    }
>  else
>    {
>      data1 = IA__g_value_peek_pointer (param_values + 0);
>      data2 = closure->data;
>    }
>  callback = (GMarshalFunc_VOID__UINT_POINTER) (marshal_data ? marshal_data : cc->callback);
>
>  callback (data1,
>            (param_values + 1)->data[0].v_uint,
>            (param_values + 2)->data[0].v_pointer,
>            data2);
>}
>
>
>void
>IA__g_cclosure_marshal_BOOLEAN__FLAGS (GClosure *closure,
>                                   GValue *return_value __attribute__((__unused__)),
>                                   guint n_param_values,
>                                   const GValue *param_values,
>                                   gpointer invocation_hint __attribute__((__unused__)),
>                                   gpointer marshal_data)
>{
>  typedef gboolean (*GMarshalFunc_BOOLEAN__FLAGS) (gpointer data1,
>                                                   guint arg_1,
>                                                   gpointer data2);
>  register GMarshalFunc_BOOLEAN__FLAGS callback;
>  register GCClosure *cc = (GCClosure*) closure;
>  register gpointer data1, data2;
>  gboolean v_return;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (return_value != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "return_value != NULL"); return; }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_param_values == 2) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_param_values == 2"); return; }; });
>
>  if ((((GClosure*) (closure))->derivative_flag))
>    {
>      data1 = closure->data;
>      data2 = IA__g_value_peek_pointer (param_values + 0);
>    }
>  else
>    {
>      data1 = IA__g_value_peek_pointer (param_values + 0);
>      data2 = closure->data;
>    }
>  callback = (GMarshalFunc_BOOLEAN__FLAGS) (marshal_data ? marshal_data : cc->callback);
>
>  v_return = callback (data1,
>                       (param_values + 1)->data[0].v_ulong,
>                       data2);
>
>  IA__g_value_set_boolean (return_value, v_return);
>}
>
>
>void
>IA__g_cclosure_marshal_STRING__OBJECT_POINTER (GClosure *closure,
>                                           GValue *return_value __attribute__((__unused__)),
>                                           guint n_param_values,
>                                           const GValue *param_values,
>                                           gpointer invocation_hint __attribute__((__unused__)),
>                                           gpointer marshal_data)
>{
>  typedef gchar* (*GMarshalFunc_STRING__OBJECT_POINTER) (gpointer data1,
>                                                         gpointer arg_1,
>                                                         gpointer arg_2,
>                                                         gpointer data2);
>  register GMarshalFunc_STRING__OBJECT_POINTER callback;
>  register GCClosure *cc = (GCClosure*) closure;
>  register gpointer data1, data2;
>  gchar* v_return;
>
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (return_value != ((void *)0)) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "return_value != NULL"); return; }; });
>  (void) __extension__ ({ if (__builtin_expect (__extension__ ({ int _g_boolean_var_; if (n_param_values == 3) _g_boolean_var_ = 1; else _g_boolean_var_ = 0; _g_boolean_var_; }), 1)) { } else { g_return_if_fail_warning ("GLib-GObject", __PRETTY_FUNCTION__, "n_param_values == 3"); return; }; });
>
>  if ((((GClosure*) (closure))->derivative_flag))
>    {
>      data1 = closure->data;
>      data2 = IA__g_value_peek_pointer (param_values + 0);
>    }
>  else
>    {
>      data1 = IA__g_value_peek_pointer (param_values + 0);
>      data2 = closure->data;
>    }
>  callback = (GMarshalFunc_STRING__OBJECT_POINTER) (marshal_data ? marshal_data : cc->callback);
>
>  v_return = callback (data1,
>                       (param_values + 1)->data[0].v_pointer,
>                       (param_values + 2)->data[0].v_pointer,
>                       data2);
>
>  IA__g_value_take_string (return_value, v_return);
>}
># 2611 "gsignal.c" 2
>
>
># 1 "gobjectaliasdef.c" 1
># 75 "gobjectaliasdef.c"
>extern __typeof (g_cclosure_marshal_BOOLEAN__FLAGS) g_cclosure_marshal_BOOLEAN__FLAGS __attribute((alias("IA__g_cclosure_marshal_BOOLEAN__FLAGS"), visibility("default")));
>
>
>extern __typeof (g_cclosure_marshal_STRING__OBJECT_POINTER) g_cclosure_marshal_STRING__OBJECT_POINTER __attribute((alias("IA__g_cclosure_marshal_STRING__OBJECT_POINTER"), visibility("default")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__BOOLEAN) g_cclosure_marshal_VOID__BOOLEAN __attribute((alias("IA__g_cclosure_marshal_VOID__BOOLEAN"), visibility("default")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__BOXED) g_cclosure_marshal_VOID__BOXED __attribute((alias("IA__g_cclosure_marshal_VOID__BOXED"), visibility("default")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__CHAR) g_cclosure_marshal_VOID__CHAR __attribute((alias("IA__g_cclosure_marshal_VOID__CHAR"), visibility("default")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__DOUBLE) g_cclosure_marshal_VOID__DOUBLE __attribute((alias("IA__g_cclosure_marshal_VOID__DOUBLE"), visibility("default")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__ENUM) g_cclosure_marshal_VOID__ENUM __attribute((alias("IA__g_cclosure_marshal_VOID__ENUM"), visibility("default")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__FLAGS) g_cclosure_marshal_VOID__FLAGS __attribute((alias("IA__g_cclosure_marshal_VOID__FLAGS"), visibility("default")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__FLOAT) g_cclosure_marshal_VOID__FLOAT __attribute((alias("IA__g_cclosure_marshal_VOID__FLOAT"), visibility("default")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__INT) g_cclosure_marshal_VOID__INT __attribute((alias("IA__g_cclosure_marshal_VOID__INT"), visibility("default")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__LONG) g_cclosure_marshal_VOID__LONG __attribute((alias("IA__g_cclosure_marshal_VOID__LONG"), visibility("default")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__OBJECT) g_cclosure_marshal_VOID__OBJECT __attribute((alias("IA__g_cclosure_marshal_VOID__OBJECT"), visibility("default")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__PARAM) g_cclosure_marshal_VOID__PARAM __attribute((alias("IA__g_cclosure_marshal_VOID__PARAM"), visibility("default")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__POINTER) g_cclosure_marshal_VOID__POINTER __attribute((alias("IA__g_cclosure_marshal_VOID__POINTER"), visibility("default")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__STRING) g_cclosure_marshal_VOID__STRING __attribute((alias("IA__g_cclosure_marshal_VOID__STRING"), visibility("default")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__UCHAR) g_cclosure_marshal_VOID__UCHAR __attribute((alias("IA__g_cclosure_marshal_VOID__UCHAR"), visibility("default")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__UINT) g_cclosure_marshal_VOID__UINT __attribute((alias("IA__g_cclosure_marshal_VOID__UINT"), visibility("default")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__UINT_POINTER) g_cclosure_marshal_VOID__UINT_POINTER __attribute((alias("IA__g_cclosure_marshal_VOID__UINT_POINTER"), visibility("default")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__ULONG) g_cclosure_marshal_VOID__ULONG __attribute((alias("IA__g_cclosure_marshal_VOID__ULONG"), visibility("default")));
>
>
>extern __typeof (g_cclosure_marshal_VOID__VOID) g_cclosure_marshal_VOID__VOID __attribute((alias("IA__g_cclosure_marshal_VOID__VOID"), visibility("default")));
># 692 "gobjectaliasdef.c"
>extern __typeof (g_signal_accumulator_true_handled) g_signal_accumulator_true_handled __attribute((alias("IA__g_signal_accumulator_true_handled"), visibility("default")));
>
>
>extern __typeof (g_signal_add_emission_hook) g_signal_add_emission_hook __attribute((alias("IA__g_signal_add_emission_hook"), visibility("default")));
>
>
>extern __typeof (g_signal_chain_from_overridden) g_signal_chain_from_overridden __attribute((alias("IA__g_signal_chain_from_overridden"), visibility("default")));
>
>
>extern __typeof (g_signal_connect_closure) g_signal_connect_closure __attribute((alias("IA__g_signal_connect_closure"), visibility("default")));
>
>
>extern __typeof (g_signal_connect_closure_by_id) g_signal_connect_closure_by_id __attribute((alias("IA__g_signal_connect_closure_by_id"), visibility("default")));
>
>
>extern __typeof (g_signal_connect_data) g_signal_connect_data __attribute((alias("IA__g_signal_connect_data"), visibility("default")));
>
>
>extern __typeof (g_signal_emit) g_signal_emit __attribute((alias("IA__g_signal_emit"), visibility("default")));
>
>
>extern __typeof (g_signal_emit_by_name) g_signal_emit_by_name __attribute((alias("IA__g_signal_emit_by_name"), visibility("default")));
>
>
>extern __typeof (g_signal_emitv) g_signal_emitv __attribute((alias("IA__g_signal_emitv"), visibility("default")));
>
>
>extern __typeof (g_signal_emit_valist) g_signal_emit_valist __attribute((alias("IA__g_signal_emit_valist"), visibility("default")));
>
>
>extern __typeof (g_signal_get_invocation_hint) g_signal_get_invocation_hint __attribute((alias("IA__g_signal_get_invocation_hint"), visibility("default")));
>
>
>extern __typeof (g_signal_handler_block) g_signal_handler_block __attribute((alias("IA__g_signal_handler_block"), visibility("default")));
>
>
>extern __typeof (g_signal_handler_disconnect) g_signal_handler_disconnect __attribute((alias("IA__g_signal_handler_disconnect"), visibility("default")));
>
>
>extern __typeof (g_signal_handler_find) g_signal_handler_find __attribute((alias("IA__g_signal_handler_find"), visibility("default")));
>
>
>extern __typeof (g_signal_handler_is_connected) g_signal_handler_is_connected __attribute((alias("IA__g_signal_handler_is_connected"), visibility("default")));
>
>
>extern __typeof (g_signal_handlers_block_matched) g_signal_handlers_block_matched __attribute((alias("IA__g_signal_handlers_block_matched"), visibility("default")));
>
>
>extern __typeof (g_signal_handlers_destroy) g_signal_handlers_destroy __attribute((alias("IA__g_signal_handlers_destroy"), visibility("default")));
>
>
>extern __typeof (g_signal_handlers_disconnect_matched) g_signal_handlers_disconnect_matched __attribute((alias("IA__g_signal_handlers_disconnect_matched"), visibility("default")));
>
>
>extern __typeof (g_signal_handlers_unblock_matched) g_signal_handlers_unblock_matched __attribute((alias("IA__g_signal_handlers_unblock_matched"), visibility("default")));
>
>
>extern __typeof (g_signal_handler_unblock) g_signal_handler_unblock __attribute((alias("IA__g_signal_handler_unblock"), visibility("default")));
>
>
>extern __typeof (g_signal_has_handler_pending) g_signal_has_handler_pending __attribute((alias("IA__g_signal_has_handler_pending"), visibility("default")));
>
>
>extern __typeof (g_signal_list_ids) g_signal_list_ids __attribute((alias("IA__g_signal_list_ids"), visibility("default")));
>
>
>extern __typeof (g_signal_lookup) g_signal_lookup __attribute((alias("IA__g_signal_lookup"), visibility("default")));
>
>
>extern __typeof (g_signal_name) g_signal_name __attribute((alias("IA__g_signal_name"), visibility("default")));
>
>
>extern __typeof (g_signal_new) g_signal_new __attribute((alias("IA__g_signal_new"), visibility("default")));
>
>
>extern __typeof (g_signal_newv) g_signal_newv __attribute((alias("IA__g_signal_newv"), visibility("default")));
>
>
>extern __typeof (g_signal_new_valist) g_signal_new_valist __attribute((alias("IA__g_signal_new_valist"), visibility("default")));
>
>
>extern __typeof (g_signal_override_class_closure) g_signal_override_class_closure __attribute((alias("IA__g_signal_override_class_closure"), visibility("default")));
>
>
>extern __typeof (g_signal_parse_name) g_signal_parse_name __attribute((alias("IA__g_signal_parse_name"), visibility("default")));
>
>
>extern __typeof (g_signal_query) g_signal_query __attribute((alias("IA__g_signal_query"), visibility("default")));
>
>
>extern __typeof (g_signal_remove_emission_hook) g_signal_remove_emission_hook __attribute((alias("IA__g_signal_remove_emission_hook"), visibility("default")));
>
>
>extern __typeof (g_signal_stop_emission) g_signal_stop_emission __attribute((alias("IA__g_signal_stop_emission"), visibility("default")));
>
>
>extern __typeof (g_signal_stop_emission_by_name) g_signal_stop_emission_by_name __attribute((alias("IA__g_signal_stop_emission_by_name"), visibility("default")));
># 2613 "gsignal.c" 2

Actions: View

Attachments on bug 450790: 308912 | 311216