Rust bindgen run on syslog-ng

lib.rs

/* automatically generated by rust-bindgen */

pub type ptrdiff_t = ::libc::c_long;
pub type size_t = ::libc::c_ulong;
pub type wchar_t = ::libc::c_int;
pub type gint8 = ::libc::c_char;
pub type guint8 = ::libc::c_uchar;
pub type gint16 = ::libc::c_short;
pub type guint16 = ::libc::c_ushort;
pub type gint32 = ::libc::c_int;
pub type guint32 = ::libc::c_uint;
pub type gint64 = ::libc::c_long;
pub type guint64 = ::libc::c_ulong;
pub type gssize = ::libc::c_long;
pub type gsize = ::libc::c_ulong;
pub type goffset = gint64;
pub type gintptr = ::libc::c_long;
pub type guintptr = ::libc::c_ulong;
pub type GPid = ::libc::c_int;
pub type __u_char = ::libc::c_uchar;
pub type __u_short = ::libc::c_ushort;
pub type __u_int = ::libc::c_uint;
pub type __u_long = ::libc::c_ulong;
pub type __int8_t = ::libc::c_char;
pub type __uint8_t = ::libc::c_uchar;
pub type __int16_t = ::libc::c_short;
pub type __uint16_t = ::libc::c_ushort;
pub type __int32_t = ::libc::c_int;
pub type __uint32_t = ::libc::c_uint;
pub type __int64_t = ::libc::c_long;
pub type __uint64_t = ::libc::c_ulong;
pub type __quad_t = ::libc::c_long;
pub type __u_quad_t = ::libc::c_ulong;
pub type __dev_t = ::libc::c_ulong;
pub type __uid_t = ::libc::c_uint;
pub type __gid_t = ::libc::c_uint;
pub type __ino_t = ::libc::c_ulong;
pub type __ino64_t = ::libc::c_ulong;
pub type __mode_t = ::libc::c_uint;
pub type __nlink_t = ::libc::c_ulong;
pub type __off_t = ::libc::c_long;
pub type __off64_t = ::libc::c_long;
pub type __pid_t = ::libc::c_int;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed1 {
    pub __val: [::libc::c_int; 2usize],
}
impl ::std::clone::Clone for Struct_Unnamed1 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed1 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type __fsid_t = Struct_Unnamed1;
pub type __clock_t = ::libc::c_long;
pub type __rlim_t = ::libc::c_ulong;
pub type __rlim64_t = ::libc::c_ulong;
pub type __id_t = ::libc::c_uint;
pub type __time_t = ::libc::c_long;
pub type __useconds_t = ::libc::c_uint;
pub type __suseconds_t = ::libc::c_long;
pub type __daddr_t = ::libc::c_int;
pub type __key_t = ::libc::c_int;
pub type __clockid_t = ::libc::c_int;
pub type __timer_t = *mut ::libc::c_void;
pub type __blksize_t = ::libc::c_long;
pub type __blkcnt_t = ::libc::c_long;
pub type __blkcnt64_t = ::libc::c_long;
pub type __fsblkcnt_t = ::libc::c_ulong;
pub type __fsblkcnt64_t = ::libc::c_ulong;
pub type __fsfilcnt_t = ::libc::c_ulong;
pub type __fsfilcnt64_t = ::libc::c_ulong;
pub type __fsword_t = ::libc::c_long;
pub type __ssize_t = ::libc::c_long;
pub type __syscall_slong_t = ::libc::c_long;
pub type __syscall_ulong_t = ::libc::c_ulong;
pub type __loff_t = __off64_t;
pub type __qaddr_t = *mut __quad_t;
pub type __caddr_t = *mut ::libc::c_char;
pub type __intptr_t = ::libc::c_long;
pub type __socklen_t = ::libc::c_uint;
pub type clock_t = __clock_t;
pub type time_t = __time_t;
pub type clockid_t = __clockid_t;
pub type timer_t = __timer_t;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_timespec {
    pub tv_sec: __time_t,
    pub tv_nsec: __syscall_slong_t,
}
impl ::std::clone::Clone for Struct_timespec {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_timespec {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tm {
    pub tm_sec: ::libc::c_int,
    pub tm_min: ::libc::c_int,
    pub tm_hour: ::libc::c_int,
    pub tm_mday: ::libc::c_int,
    pub tm_mon: ::libc::c_int,
    pub tm_year: ::libc::c_int,
    pub tm_wday: ::libc::c_int,
    pub tm_yday: ::libc::c_int,
    pub tm_isdst: ::libc::c_int,
    pub tm_gmtoff: ::libc::c_long,
    pub tm_zone: *const ::libc::c_char,
}
impl ::std::clone::Clone for Struct_tm {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_tm {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_itimerspec {
    pub it_interval: Struct_timespec,
    pub it_value: Struct_timespec,
}
impl ::std::clone::Clone for Struct_itimerspec {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_itimerspec {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type pid_t = __pid_t;
pub enum Struct___locale_data { }
#[repr(C)]
#[derive(Copy)]
pub struct Struct___locale_struct {
    pub __locales: [*mut Struct___locale_data; 13usize],
    pub __ctype_b: *const ::libc::c_ushort,
    pub __ctype_tolower: *const ::libc::c_int,
    pub __ctype_toupper: *const ::libc::c_int,
    pub __names: [*const ::libc::c_char; 13usize],
}
impl ::std::clone::Clone for Struct___locale_struct {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct___locale_struct {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type __locale_t = *mut Struct___locale_struct;
pub type locale_t = __locale_t;
pub type gchar = ::libc::c_char;
pub type gshort = ::libc::c_short;
pub type glong = ::libc::c_long;
pub type gint = ::libc::c_int;
pub type gboolean = gint;
pub type guchar = ::libc::c_uchar;
pub type gushort = ::libc::c_ushort;
pub type gulong = ::libc::c_ulong;
pub type guint = ::libc::c_uint;
pub type gfloat = ::libc::c_float;
pub type gdouble = ::libc::c_double;
pub type gpointer = *mut ::libc::c_void;
pub type gconstpointer = *const ::libc::c_void;
pub type GCompareFunc =
    ::std::option::Option<extern "C" fn(a: gconstpointer, b: gconstpointer)
                              -> gint>;
pub type GCompareDataFunc =
    ::std::option::Option<extern "C" fn(a: gconstpointer, b: gconstpointer,
                                        user_data: gpointer) -> gint>;
pub type GEqualFunc =
    ::std::option::Option<extern "C" fn(a: gconstpointer, b: gconstpointer)
                              -> gboolean>;
pub type GDestroyNotify =
    ::std::option::Option<extern "C" fn(data: gpointer) -> ()>;
pub type GFunc =
    ::std::option::Option<extern "C" fn(data: gpointer, user_data: gpointer)
                              -> ()>;
pub type GHashFunc =
    ::std::option::Option<extern "C" fn(key: gconstpointer) -> guint>;
pub type GHFunc =
    ::std::option::Option<extern "C" fn(key: gpointer, value: gpointer,
                                        user_data: gpointer) -> ()>;
pub type GFreeFunc =
    ::std::option::Option<extern "C" fn(data: gpointer) -> ()>;
pub type GTranslateFunc =
    ::std::option::Option<extern "C" fn(str: *const gchar, data: gpointer)
                              -> *const gchar>;
pub type GDoubleIEEE754 = Union__GDoubleIEEE754;
pub type GFloatIEEE754 = Union__GFloatIEEE754;
#[repr(C)]
#[derive(Copy)]
pub struct Union__GFloatIEEE754 {
    pub _bindgen_data_: [u32; 1usize],
}
impl Union__GFloatIEEE754 {
    pub unsafe fn v_float(&mut self) -> *mut gfloat {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn mpn(&mut self) -> *mut Struct_Unnamed2 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union__GFloatIEEE754 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union__GFloatIEEE754 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed2 {
    pub _bindgen_bitfield_1_: guint,
    pub _bindgen_bitfield_2_: guint,
    pub _bindgen_bitfield_3_: guint,
}
impl ::std::clone::Clone for Struct_Unnamed2 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed2 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Union__GDoubleIEEE754 {
    pub _bindgen_data_: [u64; 1usize],
}
impl Union__GDoubleIEEE754 {
    pub unsafe fn v_double(&mut self) -> *mut gdouble {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn mpn(&mut self) -> *mut Struct_Unnamed3 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union__GDoubleIEEE754 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union__GDoubleIEEE754 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed3 {
    pub _bindgen_bitfield_1_: guint,
    pub _bindgen_bitfield_2_: guint,
    pub _bindgen_bitfield_3_: guint,
    pub _bindgen_bitfield_4_: guint,
}
impl ::std::clone::Clone for Struct_Unnamed3 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed3 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type GTimeVal = Struct__GTimeVal;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GTimeVal {
    pub tv_sec: glong,
    pub tv_usec: glong,
}
impl ::std::clone::Clone for Struct__GTimeVal {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GTimeVal {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub enum Struct__GBytes { }
pub type GBytes = Struct__GBytes;
pub type GArray = Struct__GArray;
pub type GByteArray = Struct__GByteArray;
pub type GPtrArray = Struct__GPtrArray;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GArray {
    pub data: *mut gchar,
    pub len: guint,
}
impl ::std::clone::Clone for Struct__GArray {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GArray {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GByteArray {
    pub data: *mut guint8,
    pub len: guint,
}
impl ::std::clone::Clone for Struct__GByteArray {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GByteArray {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GPtrArray {
    pub pdata: *mut gpointer,
    pub len: guint,
}
impl ::std::clone::Clone for Struct__GPtrArray {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GPtrArray {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type va_list = __gnuc_va_list;
pub type __gnuc_va_list = __builtin_va_list;
pub type GQuark = guint32;
pub type GError = Struct__GError;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GError {
    pub domain: GQuark,
    pub code: gint,
    pub message: *mut gchar,
}
impl ::std::clone::Clone for Struct__GError {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GError {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type Enum_Unnamed4 = ::libc::c_uint;
pub const G_THREAD_ERROR_AGAIN: ::libc::c_uint = 0;
pub type GThreadError = Enum_Unnamed4;
pub type GThreadFunc =
    ::std::option::Option<extern "C" fn(data: gpointer) -> gpointer>;
pub type GThread = Struct__GThread;
pub type GMutex = Union__GMutex;
pub type GRecMutex = Struct__GRecMutex;
pub type GRWLock = Struct__GRWLock;
pub type GCond = Struct__GCond;
pub type GPrivate = Struct__GPrivate;
pub type GOnce = Struct__GOnce;
#[repr(C)]
#[derive(Copy)]
pub struct Union__GMutex {
    pub _bindgen_data_: [u64; 1usize],
}
impl Union__GMutex {
    pub unsafe fn p(&mut self) -> *mut gpointer {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn i(&mut self) -> *mut [guint; 2usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union__GMutex {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union__GMutex {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GRWLock {
    pub p: gpointer,
    pub i: [guint; 2usize],
}
impl ::std::clone::Clone for Struct__GRWLock {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GRWLock {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GCond {
    pub p: gpointer,
    pub i: [guint; 2usize],
}
impl ::std::clone::Clone for Struct__GCond {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GCond {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GRecMutex {
    pub p: gpointer,
    pub i: [guint; 2usize],
}
impl ::std::clone::Clone for Struct__GRecMutex {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GRecMutex {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GPrivate {
    pub p: gpointer,
    pub notify: GDestroyNotify,
    pub future: [gpointer; 2usize],
}
impl ::std::clone::Clone for Struct__GPrivate {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GPrivate {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type Enum_Unnamed5 = ::libc::c_uint;
pub const G_ONCE_STATUS_NOTCALLED: ::libc::c_uint = 0;
pub const G_ONCE_STATUS_PROGRESS: ::libc::c_uint = 1;
pub const G_ONCE_STATUS_READY: ::libc::c_uint = 2;
pub type GOnceStatus = Enum_Unnamed5;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GOnce {
    pub status: GOnceStatus,
    pub retval: gpointer,
}
impl ::std::clone::Clone for Struct__GOnce {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GOnce {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub enum Struct__GAsyncQueue { }
pub type GAsyncQueue = Struct__GAsyncQueue;
pub type __sig_atomic_t = ::libc::c_int;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed6 {
    pub __val: [::libc::c_ulong; 16usize],
}
impl ::std::clone::Clone for Struct_Unnamed6 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed6 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type __sigset_t = Struct_Unnamed6;
pub type sig_atomic_t = __sig_atomic_t;
pub type sigset_t = __sigset_t;
pub type uid_t = __uid_t;
#[repr(C)]
#[derive(Copy)]
pub struct Union_sigval {
    pub _bindgen_data_: [u64; 1usize],
}
impl Union_sigval {
    pub unsafe fn sival_int(&mut self) -> *mut ::libc::c_int {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn sival_ptr(&mut self) -> *mut *mut ::libc::c_void {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_sigval {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_sigval {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type sigval_t = Union_sigval;
pub type __sigchld_clock_t = __clock_t;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed7 {
    pub si_signo: ::libc::c_int,
    pub si_errno: ::libc::c_int,
    pub si_code: ::libc::c_int,
    pub _sifields: Union_Unnamed8,
}
impl ::std::clone::Clone for Struct_Unnamed7 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed7 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed8 {
    pub _bindgen_data_: [u64; 14usize],
}
impl Union_Unnamed8 {
    pub unsafe fn _pad(&mut self) -> *mut [::libc::c_int; 28usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn _kill(&mut self) -> *mut Struct_Unnamed9 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn _timer(&mut self) -> *mut Struct_Unnamed10 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn _rt(&mut self) -> *mut Struct_Unnamed11 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn _sigchld(&mut self) -> *mut Struct_Unnamed12 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn _sigfault(&mut self) -> *mut Struct_Unnamed13 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn _sigpoll(&mut self) -> *mut Struct_Unnamed14 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn _sigsys(&mut self) -> *mut Struct_Unnamed15 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed8 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed8 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed9 {
    pub si_pid: __pid_t,
    pub si_uid: __uid_t,
}
impl ::std::clone::Clone for Struct_Unnamed9 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed9 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed10 {
    pub si_tid: ::libc::c_int,
    pub si_overrun: ::libc::c_int,
    pub si_sigval: sigval_t,
}
impl ::std::clone::Clone for Struct_Unnamed10 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed10 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed11 {
    pub si_pid: __pid_t,
    pub si_uid: __uid_t,
    pub si_sigval: sigval_t,
}
impl ::std::clone::Clone for Struct_Unnamed11 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed11 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed12 {
    pub si_pid: __pid_t,
    pub si_uid: __uid_t,
    pub si_status: ::libc::c_int,
    pub si_utime: __sigchld_clock_t,
    pub si_stime: __sigchld_clock_t,
}
impl ::std::clone::Clone for Struct_Unnamed12 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed12 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed13 {
    pub si_addr: *mut ::libc::c_void,
    pub si_addr_lsb: ::libc::c_short,
}
impl ::std::clone::Clone for Struct_Unnamed13 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed13 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed14 {
    pub si_band: ::libc::c_long,
    pub si_fd: ::libc::c_int,
}
impl ::std::clone::Clone for Struct_Unnamed14 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed14 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed15 {
    pub _call_addr: *mut ::libc::c_void,
    pub _syscall: ::libc::c_int,
    pub _arch: ::libc::c_uint,
}
impl ::std::clone::Clone for Struct_Unnamed15 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed15 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type siginfo_t = Struct_Unnamed7;
pub type Enum_Unnamed16 = ::libc::c_int;
pub const SI_ASYNCNL: ::libc::c_int = -60;
pub const SI_TKILL: ::libc::c_int = -6;
pub const SI_SIGIO: ::libc::c_int = -5;
pub const SI_ASYNCIO: ::libc::c_int = -4;
pub const SI_MESGQ: ::libc::c_int = -3;
pub const SI_TIMER: ::libc::c_int = -2;
pub const SI_QUEUE: ::libc::c_int = -1;
pub const SI_USER: ::libc::c_int = 0;
pub const SI_KERNEL: ::libc::c_int = 128;
pub type Enum_Unnamed17 = ::libc::c_uint;
pub const ILL_ILLOPC: ::libc::c_uint = 1;
pub const ILL_ILLOPN: ::libc::c_uint = 2;
pub const ILL_ILLADR: ::libc::c_uint = 3;
pub const ILL_ILLTRP: ::libc::c_uint = 4;
pub const ILL_PRVOPC: ::libc::c_uint = 5;
pub const ILL_PRVREG: ::libc::c_uint = 6;
pub const ILL_COPROC: ::libc::c_uint = 7;
pub const ILL_BADSTK: ::libc::c_uint = 8;
pub type Enum_Unnamed18 = ::libc::c_uint;
pub const FPE_INTDIV: ::libc::c_uint = 1;
pub const FPE_INTOVF: ::libc::c_uint = 2;
pub const FPE_FLTDIV: ::libc::c_uint = 3;
pub const FPE_FLTOVF: ::libc::c_uint = 4;
pub const FPE_FLTUND: ::libc::c_uint = 5;
pub const FPE_FLTRES: ::libc::c_uint = 6;
pub const FPE_FLTINV: ::libc::c_uint = 7;
pub const FPE_FLTSUB: ::libc::c_uint = 8;
pub type Enum_Unnamed19 = ::libc::c_uint;
pub const SEGV_MAPERR: ::libc::c_uint = 1;
pub const SEGV_ACCERR: ::libc::c_uint = 2;
pub type Enum_Unnamed20 = ::libc::c_uint;
pub const BUS_ADRALN: ::libc::c_uint = 1;
pub const BUS_ADRERR: ::libc::c_uint = 2;
pub const BUS_OBJERR: ::libc::c_uint = 3;
pub const BUS_MCEERR_AR: ::libc::c_uint = 4;
pub const BUS_MCEERR_AO: ::libc::c_uint = 5;
pub type Enum_Unnamed21 = ::libc::c_uint;
pub const TRAP_BRKPT: ::libc::c_uint = 1;
pub const TRAP_TRACE: ::libc::c_uint = 2;
pub type Enum_Unnamed22 = ::libc::c_uint;
pub const CLD_EXITED: ::libc::c_uint = 1;
pub const CLD_KILLED: ::libc::c_uint = 2;
pub const CLD_DUMPED: ::libc::c_uint = 3;
pub const CLD_TRAPPED: ::libc::c_uint = 4;
pub const CLD_STOPPED: ::libc::c_uint = 5;
pub const CLD_CONTINUED: ::libc::c_uint = 6;
pub type Enum_Unnamed23 = ::libc::c_uint;
pub const POLL_IN: ::libc::c_uint = 1;
pub const POLL_OUT: ::libc::c_uint = 2;
pub const POLL_MSG: ::libc::c_uint = 3;
pub const POLL_ERR: ::libc::c_uint = 4;
pub const POLL_PRI: ::libc::c_uint = 5;
pub const POLL_HUP: ::libc::c_uint = 6;
pub type pthread_attr_t = Union_pthread_attr_t;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_sigevent {
    pub sigev_value: sigval_t,
    pub sigev_signo: ::libc::c_int,
    pub sigev_notify: ::libc::c_int,
    pub _sigev_un: Union_Unnamed24,
}
impl ::std::clone::Clone for Struct_sigevent {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_sigevent {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed24 {
    pub _bindgen_data_: [u64; 6usize],
}
impl Union_Unnamed24 {
    pub unsafe fn _pad(&mut self) -> *mut [::libc::c_int; 12usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn _tid(&mut self) -> *mut __pid_t {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn _sigev_thread(&mut self) -> *mut Struct_Unnamed25 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed24 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed24 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed25 {
    pub _function: ::std::option::Option<extern "C" fn(arg1: sigval_t) -> ()>,
    pub _attribute: *mut pthread_attr_t,
}
impl ::std::clone::Clone for Struct_Unnamed25 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed25 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type sigevent_t = Struct_sigevent;
pub type Enum_Unnamed26 = ::libc::c_uint;
pub const SIGEV_SIGNAL: ::libc::c_uint = 0;
pub const SIGEV_NONE: ::libc::c_uint = 1;
pub const SIGEV_THREAD: ::libc::c_uint = 2;
pub const SIGEV_THREAD_ID: ::libc::c_uint = 4;
pub type __sighandler_t =
    ::std::option::Option<extern "C" fn(arg1: ::libc::c_int) -> ()>;
pub type sig_t = __sighandler_t;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_sigaction {
    pub __sigaction_handler: Union_Unnamed27,
    pub sa_mask: __sigset_t,
    pub sa_flags: ::libc::c_int,
    pub sa_restorer: ::std::option::Option<extern "C" fn() -> ()>,
}
impl ::std::clone::Clone for Struct_sigaction {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_sigaction {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed27 {
    pub _bindgen_data_: [u64; 1usize],
}
impl Union_Unnamed27 {
    pub unsafe fn sa_handler(&mut self) -> *mut __sighandler_t {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn sa_sigaction(&mut self)
     ->
         *mut ::std::option::Option<extern "C" fn(arg1: ::libc::c_int,
                                                  arg2: *mut siginfo_t,
                                                  arg3: *mut ::libc::c_void)
                                        -> ()> {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed27 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed27 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_sigvec {
    pub sv_handler: __sighandler_t,
    pub sv_mask: ::libc::c_int,
    pub sv_flags: ::libc::c_int,
}
impl ::std::clone::Clone for Struct_sigvec {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_sigvec {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__fpx_sw_bytes {
    pub magic1: __uint32_t,
    pub extended_size: __uint32_t,
    pub xstate_bv: __uint64_t,
    pub xstate_size: __uint32_t,
    pub padding: [__uint32_t; 7usize],
}
impl ::std::clone::Clone for Struct__fpx_sw_bytes {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__fpx_sw_bytes {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__fpreg {
    pub significand: [::libc::c_ushort; 4usize],
    pub exponent: ::libc::c_ushort,
}
impl ::std::clone::Clone for Struct__fpreg {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__fpreg {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__fpxreg {
    pub significand: [::libc::c_ushort; 4usize],
    pub exponent: ::libc::c_ushort,
    pub padding: [::libc::c_ushort; 3usize],
}
impl ::std::clone::Clone for Struct__fpxreg {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__fpxreg {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__xmmreg {
    pub element: [__uint32_t; 4usize],
}
impl ::std::clone::Clone for Struct__xmmreg {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__xmmreg {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__fpstate {
    pub cwd: __uint16_t,
    pub swd: __uint16_t,
    pub ftw: __uint16_t,
    pub fop: __uint16_t,
    pub rip: __uint64_t,
    pub rdp: __uint64_t,
    pub mxcsr: __uint32_t,
    pub mxcr_mask: __uint32_t,
    pub _st: [Struct__fpxreg; 8usize],
    pub _xmm: [Struct__xmmreg; 16usize],
    pub padding: [__uint32_t; 24usize],
}
impl ::std::clone::Clone for Struct__fpstate {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__fpstate {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_sigcontext {
    pub r8: __uint64_t,
    pub r9: __uint64_t,
    pub r10: __uint64_t,
    pub r11: __uint64_t,
    pub r12: __uint64_t,
    pub r13: __uint64_t,
    pub r14: __uint64_t,
    pub r15: __uint64_t,
    pub rdi: __uint64_t,
    pub rsi: __uint64_t,
    pub rbp: __uint64_t,
    pub rbx: __uint64_t,
    pub rdx: __uint64_t,
    pub rax: __uint64_t,
    pub rcx: __uint64_t,
    pub rsp: __uint64_t,
    pub rip: __uint64_t,
    pub eflags: __uint64_t,
    pub cs: ::libc::c_ushort,
    pub gs: ::libc::c_ushort,
    pub fs: ::libc::c_ushort,
    pub __pad0: ::libc::c_ushort,
    pub err: __uint64_t,
    pub trapno: __uint64_t,
    pub oldmask: __uint64_t,
    pub cr2: __uint64_t,
    pub _bindgen_data_1_: [u64; 1usize],
    pub __reserved1: [__uint64_t; 8usize],
}
impl Struct_sigcontext {
    pub unsafe fn fpstate(&mut self) -> *mut *mut Struct__fpstate {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_1_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __fpstate_word(&mut self) -> *mut __uint64_t {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_1_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Struct_sigcontext {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_sigcontext {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__xsave_hdr {
    pub xstate_bv: __uint64_t,
    pub reserved1: [__uint64_t; 2usize],
    pub reserved2: [__uint64_t; 5usize],
}
impl ::std::clone::Clone for Struct__xsave_hdr {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__xsave_hdr {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__ymmh_state {
    pub ymmh_space: [__uint32_t; 64usize],
}
impl ::std::clone::Clone for Struct__ymmh_state {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__ymmh_state {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__xstate {
    pub fpstate: Struct__fpstate,
    pub xstate_hdr: Struct__xsave_hdr,
    pub ymmh: Struct__ymmh_state,
}
impl ::std::clone::Clone for Struct__xstate {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__xstate {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_sigstack {
    pub ss_sp: *mut ::libc::c_void,
    pub ss_onstack: ::libc::c_int,
}
impl ::std::clone::Clone for Struct_sigstack {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_sigstack {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type Enum_Unnamed28 = ::libc::c_uint;
pub const SS_ONSTACK: ::libc::c_uint = 1;
pub const SS_DISABLE: ::libc::c_uint = 2;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_sigaltstack {
    pub ss_sp: *mut ::libc::c_void,
    pub ss_flags: ::libc::c_int,
    pub ss_size: size_t,
}
impl ::std::clone::Clone for Struct_sigaltstack {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_sigaltstack {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type stack_t = Struct_sigaltstack;
pub type greg_t = ::libc::c_longlong;
pub type gregset_t = [greg_t; 23usize];
#[repr(C)]
#[derive(Copy)]
pub struct Struct__libc_fpxreg {
    pub significand: [::libc::c_ushort; 4usize],
    pub exponent: ::libc::c_ushort,
    pub padding: [::libc::c_ushort; 3usize],
}
impl ::std::clone::Clone for Struct__libc_fpxreg {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__libc_fpxreg {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__libc_xmmreg {
    pub element: [__uint32_t; 4usize],
}
impl ::std::clone::Clone for Struct__libc_xmmreg {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__libc_xmmreg {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__libc_fpstate {
    pub cwd: __uint16_t,
    pub swd: __uint16_t,
    pub ftw: __uint16_t,
    pub fop: __uint16_t,
    pub rip: __uint64_t,
    pub rdp: __uint64_t,
    pub mxcsr: __uint32_t,
    pub mxcr_mask: __uint32_t,
    pub _st: [Struct__libc_fpxreg; 8usize],
    pub _xmm: [Struct__libc_xmmreg; 16usize],
    pub padding: [__uint32_t; 24usize],
}
impl ::std::clone::Clone for Struct__libc_fpstate {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__libc_fpstate {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fpregset_t = *mut Struct__libc_fpstate;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed29 {
    pub gregs: gregset_t,
    pub fpregs: fpregset_t,
    pub __reserved1: [::libc::c_ulonglong; 8usize],
}
impl ::std::clone::Clone for Struct_Unnamed29 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed29 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type mcontext_t = Struct_Unnamed29;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_ucontext {
    pub uc_flags: ::libc::c_ulong,
    pub uc_link: *mut Struct_ucontext,
    pub uc_stack: stack_t,
    pub uc_mcontext: mcontext_t,
    pub uc_sigmask: __sigset_t,
    pub __fpregs_mem: Struct__libc_fpstate,
}
impl ::std::clone::Clone for Struct_ucontext {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_ucontext {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type ucontext_t = Struct_ucontext;
pub type pthread_t = ::libc::c_ulong;
#[repr(C)]
#[derive(Copy)]
pub struct Union_pthread_attr_t {
    pub _bindgen_data_: [u64; 7usize],
}
impl Union_pthread_attr_t {
    pub unsafe fn __size(&mut self) -> *mut [::libc::c_char; 56usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __align(&mut self) -> *mut ::libc::c_long {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_pthread_attr_t {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_pthread_attr_t {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct___pthread_internal_list {
    pub __prev: *mut Struct___pthread_internal_list,
    pub __next: *mut Struct___pthread_internal_list,
}
impl ::std::clone::Clone for Struct___pthread_internal_list {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct___pthread_internal_list {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type __pthread_list_t = Struct___pthread_internal_list;
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed30 {
    pub _bindgen_data_: [u64; 5usize],
}
impl Union_Unnamed30 {
    pub unsafe fn __data(&mut self) -> *mut Struct___pthread_mutex_s {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __size(&mut self) -> *mut [::libc::c_char; 40usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __align(&mut self) -> *mut ::libc::c_long {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed30 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed30 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct___pthread_mutex_s {
    pub __lock: ::libc::c_int,
    pub __count: ::libc::c_uint,
    pub __owner: ::libc::c_int,
    pub __nusers: ::libc::c_uint,
    pub __kind: ::libc::c_int,
    pub __spins: ::libc::c_short,
    pub __elision: ::libc::c_short,
    pub __list: __pthread_list_t,
}
impl ::std::clone::Clone for Struct___pthread_mutex_s {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct___pthread_mutex_s {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type pthread_mutex_t = Union_Unnamed30;
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed31 {
    pub _bindgen_data_: [u32; 1usize],
}
impl Union_Unnamed31 {
    pub unsafe fn __size(&mut self) -> *mut [::libc::c_char; 4usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __align(&mut self) -> *mut ::libc::c_int {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed31 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed31 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type pthread_mutexattr_t = Union_Unnamed31;
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed32 {
    pub _bindgen_data_: [u64; 6usize],
}
impl Union_Unnamed32 {
    pub unsafe fn __data(&mut self) -> *mut Struct_Unnamed33 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __size(&mut self) -> *mut [::libc::c_char; 48usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __align(&mut self) -> *mut ::libc::c_longlong {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed32 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed32 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed33 {
    pub __lock: ::libc::c_int,
    pub __futex: ::libc::c_uint,
    pub __total_seq: ::libc::c_ulonglong,
    pub __wakeup_seq: ::libc::c_ulonglong,
    pub __woken_seq: ::libc::c_ulonglong,
    pub __mutex: *mut ::libc::c_void,
    pub __nwaiters: ::libc::c_uint,
    pub __broadcast_seq: ::libc::c_uint,
}
impl ::std::clone::Clone for Struct_Unnamed33 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed33 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type pthread_cond_t = Union_Unnamed32;
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed34 {
    pub _bindgen_data_: [u32; 1usize],
}
impl Union_Unnamed34 {
    pub unsafe fn __size(&mut self) -> *mut [::libc::c_char; 4usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __align(&mut self) -> *mut ::libc::c_int {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed34 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed34 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type pthread_condattr_t = Union_Unnamed34;
pub type pthread_key_t = ::libc::c_uint;
pub type pthread_once_t = ::libc::c_int;
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed35 {
    pub _bindgen_data_: [u64; 7usize],
}
impl Union_Unnamed35 {
    pub unsafe fn __data(&mut self) -> *mut Struct_Unnamed36 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __size(&mut self) -> *mut [::libc::c_char; 56usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __align(&mut self) -> *mut ::libc::c_long {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed35 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed35 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed36 {
    pub __lock: ::libc::c_int,
    pub __nr_readers: ::libc::c_uint,
    pub __readers_wakeup: ::libc::c_uint,
    pub __writer_wakeup: ::libc::c_uint,
    pub __nr_readers_queued: ::libc::c_uint,
    pub __nr_writers_queued: ::libc::c_uint,
    pub __writer: ::libc::c_int,
    pub __shared: ::libc::c_int,
    pub __pad1: ::libc::c_ulong,
    pub __pad2: ::libc::c_ulong,
    pub __flags: ::libc::c_uint,
}
impl ::std::clone::Clone for Struct_Unnamed36 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed36 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type pthread_rwlock_t = Union_Unnamed35;
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed37 {
    pub _bindgen_data_: [u64; 1usize],
}
impl Union_Unnamed37 {
    pub unsafe fn __size(&mut self) -> *mut [::libc::c_char; 8usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __align(&mut self) -> *mut ::libc::c_long {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed37 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed37 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type pthread_rwlockattr_t = Union_Unnamed37;
pub type pthread_spinlock_t = ::libc::c_int;
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed38 {
    pub _bindgen_data_: [u64; 4usize],
}
impl Union_Unnamed38 {
    pub unsafe fn __size(&mut self) -> *mut [::libc::c_char; 32usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __align(&mut self) -> *mut ::libc::c_long {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed38 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed38 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type pthread_barrier_t = Union_Unnamed38;
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed39 {
    pub _bindgen_data_: [u32; 1usize],
}
impl Union_Unnamed39 {
    pub unsafe fn __size(&mut self) -> *mut [::libc::c_char; 4usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __align(&mut self) -> *mut ::libc::c_int {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed39 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed39 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type pthread_barrierattr_t = Union_Unnamed39;
pub type Enum_Unnamed40 = ::libc::c_uint;
pub const G_BOOKMARK_FILE_ERROR_INVALID_URI: ::libc::c_uint = 0;
pub const G_BOOKMARK_FILE_ERROR_INVALID_VALUE: ::libc::c_uint = 1;
pub const G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED: ::libc::c_uint = 2;
pub const G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND: ::libc::c_uint = 3;
pub const G_BOOKMARK_FILE_ERROR_READ: ::libc::c_uint = 4;
pub const G_BOOKMARK_FILE_ERROR_UNKNOWN_ENCODING: ::libc::c_uint = 5;
pub const G_BOOKMARK_FILE_ERROR_WRITE: ::libc::c_uint = 6;
pub const G_BOOKMARK_FILE_ERROR_FILE_NOT_FOUND: ::libc::c_uint = 7;
pub type GBookmarkFileError = Enum_Unnamed40;
pub enum Struct__GBookmarkFile { }
pub type GBookmarkFile = Struct__GBookmarkFile;
pub type Enum_Unnamed41 = ::libc::c_uint;
pub const G_CHECKSUM_MD5: ::libc::c_uint = 0;
pub const G_CHECKSUM_SHA1: ::libc::c_uint = 1;
pub const G_CHECKSUM_SHA256: ::libc::c_uint = 2;
pub const G_CHECKSUM_SHA512: ::libc::c_uint = 3;
pub type GChecksumType = Enum_Unnamed41;
pub enum Struct__GChecksum { }
pub type GChecksum = Struct__GChecksum;
pub type Enum_Unnamed42 = ::libc::c_uint;
pub const G_CONVERT_ERROR_NO_CONVERSION: ::libc::c_uint = 0;
pub const G_CONVERT_ERROR_ILLEGAL_SEQUENCE: ::libc::c_uint = 1;
pub const G_CONVERT_ERROR_FAILED: ::libc::c_uint = 2;
pub const G_CONVERT_ERROR_PARTIAL_INPUT: ::libc::c_uint = 3;
pub const G_CONVERT_ERROR_BAD_URI: ::libc::c_uint = 4;
pub const G_CONVERT_ERROR_NOT_ABSOLUTE_PATH: ::libc::c_uint = 5;
pub const G_CONVERT_ERROR_NO_MEMORY: ::libc::c_uint = 6;
pub type GConvertError = Enum_Unnamed42;
pub enum Struct__GIConv { }
pub type GIConv = *mut Struct__GIConv;
pub enum Struct__GData { }
pub type GData = Struct__GData;
pub type GDataForeachFunc =
    ::std::option::Option<extern "C" fn(key_id: GQuark, data: gpointer,
                                        user_data: gpointer) -> ()>;
pub type GDuplicateFunc =
    ::std::option::Option<extern "C" fn(data: gpointer, user_data: gpointer)
                              -> gpointer>;
pub type GTime = gint32;
pub type GDateYear = guint16;
pub type GDateDay = guint8;
pub type GDate = Struct__GDate;
pub type Enum_Unnamed43 = ::libc::c_uint;
pub const G_DATE_DAY: ::libc::c_uint = 0;
pub const G_DATE_MONTH: ::libc::c_uint = 1;
pub const G_DATE_YEAR: ::libc::c_uint = 2;
pub type GDateDMY = Enum_Unnamed43;
pub type Enum_Unnamed44 = ::libc::c_uint;
pub const G_DATE_BAD_WEEKDAY: ::libc::c_uint = 0;
pub const G_DATE_MONDAY: ::libc::c_uint = 1;
pub const G_DATE_TUESDAY: ::libc::c_uint = 2;
pub const G_DATE_WEDNESDAY: ::libc::c_uint = 3;
pub const G_DATE_THURSDAY: ::libc::c_uint = 4;
pub const G_DATE_FRIDAY: ::libc::c_uint = 5;
pub const G_DATE_SATURDAY: ::libc::c_uint = 6;
pub const G_DATE_SUNDAY: ::libc::c_uint = 7;
pub type GDateWeekday = Enum_Unnamed44;
pub type Enum_Unnamed45 = ::libc::c_uint;
pub const G_DATE_BAD_MONTH: ::libc::c_uint = 0;
pub const G_DATE_JANUARY: ::libc::c_uint = 1;
pub const G_DATE_FEBRUARY: ::libc::c_uint = 2;
pub const G_DATE_MARCH: ::libc::c_uint = 3;
pub const G_DATE_APRIL: ::libc::c_uint = 4;
pub const G_DATE_MAY: ::libc::c_uint = 5;
pub const G_DATE_JUNE: ::libc::c_uint = 6;
pub const G_DATE_JULY: ::libc::c_uint = 7;
pub const G_DATE_AUGUST: ::libc::c_uint = 8;
pub const G_DATE_SEPTEMBER: ::libc::c_uint = 9;
pub const G_DATE_OCTOBER: ::libc::c_uint = 10;
pub const G_DATE_NOVEMBER: ::libc::c_uint = 11;
pub const G_DATE_DECEMBER: ::libc::c_uint = 12;
pub type GDateMonth = Enum_Unnamed45;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GDate {
    pub _bindgen_bitfield_1_: guint,
    pub _bindgen_bitfield_2_: guint,
    pub _bindgen_bitfield_3_: guint,
    pub _bindgen_bitfield_4_: guint,
    pub _bindgen_bitfield_5_: guint,
    pub _bindgen_bitfield_6_: guint,
}
impl ::std::clone::Clone for Struct__GDate {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GDate {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub enum Struct__GTimeZone { }
pub type GTimeZone = Struct__GTimeZone;
pub type Enum_Unnamed46 = ::libc::c_uint;
pub const G_TIME_TYPE_STANDARD: ::libc::c_uint = 0;
pub const G_TIME_TYPE_DAYLIGHT: ::libc::c_uint = 1;
pub const G_TIME_TYPE_UNIVERSAL: ::libc::c_uint = 2;
pub type GTimeType = Enum_Unnamed46;
pub type GTimeSpan = gint64;
pub enum Struct__GDateTime { }
pub type GDateTime = Struct__GDateTime;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_dirent {
    pub d_ino: __ino_t,
    pub d_off: __off_t,
    pub d_reclen: ::libc::c_ushort,
    pub d_type: ::libc::c_uchar,
    pub d_name: [::libc::c_char; 256usize],
}
impl ::std::clone::Clone for Struct_dirent {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_dirent {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type Enum_Unnamed47 = ::libc::c_uint;
pub const DT_UNKNOWN: ::libc::c_uint = 0;
pub const DT_FIFO: ::libc::c_uint = 1;
pub const DT_CHR: ::libc::c_uint = 2;
pub const DT_DIR: ::libc::c_uint = 4;
pub const DT_BLK: ::libc::c_uint = 6;
pub const DT_REG: ::libc::c_uint = 8;
pub const DT_LNK: ::libc::c_uint = 10;
pub const DT_SOCK: ::libc::c_uint = 12;
pub const DT_WHT: ::libc::c_uint = 14;
pub enum Struct___dirstream { }
pub type DIR = Struct___dirstream;
pub enum Struct__GDir { }
pub type GDir = Struct__GDir;
pub type Enum_Unnamed48 = ::libc::c_uint;
pub const G_FILE_ERROR_EXIST: ::libc::c_uint = 0;
pub const G_FILE_ERROR_ISDIR: ::libc::c_uint = 1;
pub const G_FILE_ERROR_ACCES: ::libc::c_uint = 2;
pub const G_FILE_ERROR_NAMETOOLONG: ::libc::c_uint = 3;
pub const G_FILE_ERROR_NOENT: ::libc::c_uint = 4;
pub const G_FILE_ERROR_NOTDIR: ::libc::c_uint = 5;
pub const G_FILE_ERROR_NXIO: ::libc::c_uint = 6;
pub const G_FILE_ERROR_NODEV: ::libc::c_uint = 7;
pub const G_FILE_ERROR_ROFS: ::libc::c_uint = 8;
pub const G_FILE_ERROR_TXTBSY: ::libc::c_uint = 9;
pub const G_FILE_ERROR_FAULT: ::libc::c_uint = 10;
pub const G_FILE_ERROR_LOOP: ::libc::c_uint = 11;
pub const G_FILE_ERROR_NOSPC: ::libc::c_uint = 12;
pub const G_FILE_ERROR_NOMEM: ::libc::c_uint = 13;
pub const G_FILE_ERROR_MFILE: ::libc::c_uint = 14;
pub const G_FILE_ERROR_NFILE: ::libc::c_uint = 15;
pub const G_FILE_ERROR_BADF: ::libc::c_uint = 16;
pub const G_FILE_ERROR_INVAL: ::libc::c_uint = 17;
pub const G_FILE_ERROR_PIPE: ::libc::c_uint = 18;
pub const G_FILE_ERROR_AGAIN: ::libc::c_uint = 19;
pub const G_FILE_ERROR_INTR: ::libc::c_uint = 20;
pub const G_FILE_ERROR_IO: ::libc::c_uint = 21;
pub const G_FILE_ERROR_PERM: ::libc::c_uint = 22;
pub const G_FILE_ERROR_NOSYS: ::libc::c_uint = 23;
pub const G_FILE_ERROR_FAILED: ::libc::c_uint = 24;
pub type GFileError = Enum_Unnamed48;
pub type Enum_Unnamed49 = ::libc::c_uint;
pub const G_FILE_TEST_IS_REGULAR: ::libc::c_uint = 1;
pub const G_FILE_TEST_IS_SYMLINK: ::libc::c_uint = 2;
pub const G_FILE_TEST_IS_DIR: ::libc::c_uint = 4;
pub const G_FILE_TEST_IS_EXECUTABLE: ::libc::c_uint = 8;
pub const G_FILE_TEST_EXISTS: ::libc::c_uint = 16;
pub type GFileTest = Enum_Unnamed49;
pub type GMemVTable = Struct__GMemVTable;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GMemVTable {
    pub malloc: ::std::option::Option<extern "C" fn(n_bytes: gsize)
                                          -> gpointer>,
    pub realloc: ::std::option::Option<extern "C" fn(mem: gpointer,
                                                     n_bytes: gsize)
                                           -> gpointer>,
    pub free: ::std::option::Option<extern "C" fn(mem: gpointer) -> ()>,
    pub calloc: ::std::option::Option<extern "C" fn(n_blocks: gsize,
                                                    n_block_bytes: gsize)
                                          -> gpointer>,
    pub try_malloc: ::std::option::Option<extern "C" fn(n_bytes: gsize)
                                              -> gpointer>,
    pub try_realloc: ::std::option::Option<extern "C" fn(mem: gpointer,
                                                         n_bytes: gsize)
                                               -> gpointer>,
}
impl ::std::clone::Clone for Struct__GMemVTable {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GMemVTable {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type GNode = Struct__GNode;
pub type Enum_Unnamed50 = ::libc::c_uint;
pub const G_TRAVERSE_LEAVES: ::libc::c_uint = 1;
pub const G_TRAVERSE_NON_LEAVES: ::libc::c_uint = 2;
pub const G_TRAVERSE_ALL: ::libc::c_uint = 3;
pub const G_TRAVERSE_MASK: ::libc::c_uint = 3;
pub const G_TRAVERSE_LEAFS: ::libc::c_uint = 1;
pub const G_TRAVERSE_NON_LEAFS: ::libc::c_uint = 2;
pub type GTraverseFlags = Enum_Unnamed50;
pub type Enum_Unnamed51 = ::libc::c_uint;
pub const G_IN_ORDER: ::libc::c_uint = 0;
pub const G_PRE_ORDER: ::libc::c_uint = 1;
pub const G_POST_ORDER: ::libc::c_uint = 2;
pub const G_LEVEL_ORDER: ::libc::c_uint = 3;
pub type GTraverseType = Enum_Unnamed51;
pub type GNodeTraverseFunc =
    ::std::option::Option<extern "C" fn(node: *mut GNode, data: gpointer)
                              -> gboolean>;
pub type GNodeForeachFunc =
    ::std::option::Option<extern "C" fn(node: *mut GNode, data: gpointer)
                              -> ()>;
pub type GCopyFunc =
    ::std::option::Option<extern "C" fn(src: gconstpointer, data: gpointer)
                              -> gpointer>;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GNode {
    pub data: gpointer,
    pub next: *mut GNode,
    pub prev: *mut GNode,
    pub parent: *mut GNode,
    pub children: *mut GNode,
}
impl ::std::clone::Clone for Struct__GNode {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GNode {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type GList = Struct__GList;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GList {
    pub data: gpointer,
    pub next: *mut GList,
    pub prev: *mut GList,
}
impl ::std::clone::Clone for Struct__GList {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GList {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub enum Struct__GHashTable { }
pub type GHashTable = Struct__GHashTable;
pub type GHRFunc =
    ::std::option::Option<extern "C" fn(key: gpointer, value: gpointer,
                                        user_data: gpointer) -> gboolean>;
pub type GHashTableIter = Struct__GHashTableIter;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GHashTableIter {
    pub dummy1: gpointer,
    pub dummy2: gpointer,
    pub dummy3: gpointer,
    pub dummy4: ::libc::c_int,
    pub dummy5: gboolean,
    pub dummy6: gpointer,
}
impl ::std::clone::Clone for Struct__GHashTableIter {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GHashTableIter {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub enum Struct__GHmac { }
pub type GHmac = Struct__GHmac;
pub type GHook = Struct__GHook;
pub type GHookList = Struct__GHookList;
pub type GHookCompareFunc =
    ::std::option::Option<extern "C" fn(new_hook: *mut GHook,
                                        sibling: *mut GHook) -> gint>;
pub type GHookFindFunc =
    ::std::option::Option<extern "C" fn(hook: *mut GHook, data: gpointer)
                              -> gboolean>;
pub type GHookMarshaller =
    ::std::option::Option<extern "C" fn(hook: *mut GHook,
                                        marshal_data: gpointer) -> ()>;
pub type GHookCheckMarshaller =
    ::std::option::Option<extern "C" fn(hook: *mut GHook,
                                        marshal_data: gpointer) -> gboolean>;
pub type GHookFunc =
    ::std::option::Option<extern "C" fn(data: gpointer) -> ()>;
pub type GHookCheckFunc =
    ::std::option::Option<extern "C" fn(data: gpointer) -> gboolean>;
pub type GHookFinalizeFunc =
    ::std::option::Option<extern "C" fn(hook_list: *mut GHookList,
                                        hook: *mut GHook) -> ()>;
pub type Enum_Unnamed52 = ::libc::c_uint;
pub const G_HOOK_FLAG_ACTIVE: ::libc::c_uint = 1;
pub const G_HOOK_FLAG_IN_CALL: ::libc::c_uint = 2;
pub const G_HOOK_FLAG_MASK: ::libc::c_uint = 15;
pub type GHookFlagMask = Enum_Unnamed52;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GHookList {
    pub seq_id: gulong,
    pub _bindgen_bitfield_1_: guint,
    pub _bindgen_bitfield_2_: guint,
    pub hooks: *mut GHook,
    pub dummy3: gpointer,
    pub finalize_hook: GHookFinalizeFunc,
    pub dummy: [gpointer; 2usize],
}
impl ::std::clone::Clone for Struct__GHookList {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GHookList {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GHook {
    pub data: gpointer,
    pub next: *mut GHook,
    pub prev: *mut GHook,
    pub ref_count: guint,
    pub hook_id: gulong,
    pub flags: guint,
    pub func: gpointer,
    pub destroy: GDestroyNotify,
}
impl ::std::clone::Clone for Struct__GHook {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GHook {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type GPollFD = Struct__GPollFD;
pub type GPollFunc =
    ::std::option::Option<extern "C" fn(ufds: *mut GPollFD, nfsd: guint,
                                        timeout_: gint) -> gint>;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GPollFD {
    pub fd: gint,
    pub events: gushort,
    pub revents: gushort,
}
impl ::std::clone::Clone for Struct__GPollFD {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GPollFD {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type GSList = Struct__GSList;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GSList {
    pub data: gpointer,
    pub next: *mut GSList,
}
impl ::std::clone::Clone for Struct__GSList {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GSList {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type Enum_Unnamed53 = ::libc::c_uint;
pub const G_IO_IN: ::libc::c_uint = 1;
pub const G_IO_OUT: ::libc::c_uint = 4;
pub const G_IO_PRI: ::libc::c_uint = 2;
pub const G_IO_ERR: ::libc::c_uint = 8;
pub const G_IO_HUP: ::libc::c_uint = 16;
pub const G_IO_NVAL: ::libc::c_uint = 32;
pub type GIOCondition = Enum_Unnamed53;
pub enum Struct__GMainContext { }
pub type GMainContext = Struct__GMainContext;
pub enum Struct__GMainLoop { }
pub type GMainLoop = Struct__GMainLoop;
pub type GSource = Struct__GSource;
pub enum Struct__GSourcePrivate { }
pub type GSourcePrivate = Struct__GSourcePrivate;
pub type GSourceCallbackFuncs = Struct__GSourceCallbackFuncs;
pub type GSourceFuncs = Struct__GSourceFuncs;
pub type GSourceFunc =
    ::std::option::Option<extern "C" fn(user_data: gpointer) -> gboolean>;
pub type GChildWatchFunc =
    ::std::option::Option<extern "C" fn(pid: GPid, status: gint,
                                        user_data: gpointer) -> ()>;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GSource {
    pub callback_data: gpointer,
    pub callback_funcs: *mut GSourceCallbackFuncs,
    pub source_funcs: *const GSourceFuncs,
    pub ref_count: guint,
    pub context: *mut GMainContext,
    pub priority: gint,
    pub flags: guint,
    pub source_id: guint,
    pub poll_fds: *mut GSList,
    pub prev: *mut GSource,
    pub next: *mut GSource,
    pub name: *mut ::libc::c_char,
    pub _priv: *mut GSourcePrivate,
}
impl ::std::clone::Clone for Struct__GSource {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GSource {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GSourceCallbackFuncs {
    pub _ref: ::std::option::Option<extern "C" fn(cb_data: gpointer) -> ()>,
    pub unref: ::std::option::Option<extern "C" fn(cb_data: gpointer) -> ()>,
    pub get: ::std::option::Option<extern "C" fn(cb_data: gpointer,
                                                 source: *mut GSource,
                                                 func: *mut GSourceFunc,
                                                 data: *mut gpointer) -> ()>,
}
impl ::std::clone::Clone for Struct__GSourceCallbackFuncs {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GSourceCallbackFuncs {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type GSourceDummyMarshal = ::std::option::Option<extern "C" fn() -> ()>;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GSourceFuncs {
    pub prepare: ::std::option::Option<extern "C" fn(source: *mut GSource,
                                                     timeout_: *mut gint)
                                           -> gboolean>,
    pub check: ::std::option::Option<extern "C" fn(source: *mut GSource)
                                         -> gboolean>,
    pub dispatch: ::std::option::Option<extern "C" fn(source: *mut GSource,
                                                      callback: GSourceFunc,
                                                      user_data: gpointer)
                                            -> gboolean>,
    pub finalize: ::std::option::Option<extern "C" fn(source: *mut GSource)
                                            -> ()>,
    pub closure_callback: GSourceFunc,
    pub closure_marshal: GSourceDummyMarshal,
}
impl ::std::clone::Clone for Struct__GSourceFuncs {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GSourceFuncs {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type gunichar = guint32;
pub type gunichar2 = guint16;
pub type Enum_Unnamed54 = ::libc::c_uint;
pub const G_UNICODE_CONTROL: ::libc::c_uint = 0;
pub const G_UNICODE_FORMAT: ::libc::c_uint = 1;
pub const G_UNICODE_UNASSIGNED: ::libc::c_uint = 2;
pub const G_UNICODE_PRIVATE_USE: ::libc::c_uint = 3;
pub const G_UNICODE_SURROGATE: ::libc::c_uint = 4;
pub const G_UNICODE_LOWERCASE_LETTER: ::libc::c_uint = 5;
pub const G_UNICODE_MODIFIER_LETTER: ::libc::c_uint = 6;
pub const G_UNICODE_OTHER_LETTER: ::libc::c_uint = 7;
pub const G_UNICODE_TITLECASE_LETTER: ::libc::c_uint = 8;
pub const G_UNICODE_UPPERCASE_LETTER: ::libc::c_uint = 9;
pub const G_UNICODE_SPACING_MARK: ::libc::c_uint = 10;
pub const G_UNICODE_ENCLOSING_MARK: ::libc::c_uint = 11;
pub const G_UNICODE_NON_SPACING_MARK: ::libc::c_uint = 12;
pub const G_UNICODE_DECIMAL_NUMBER: ::libc::c_uint = 13;
pub const G_UNICODE_LETTER_NUMBER: ::libc::c_uint = 14;
pub const G_UNICODE_OTHER_NUMBER: ::libc::c_uint = 15;
pub const G_UNICODE_CONNECT_PUNCTUATION: ::libc::c_uint = 16;
pub const G_UNICODE_DASH_PUNCTUATION: ::libc::c_uint = 17;
pub const G_UNICODE_CLOSE_PUNCTUATION: ::libc::c_uint = 18;
pub const G_UNICODE_FINAL_PUNCTUATION: ::libc::c_uint = 19;
pub const G_UNICODE_INITIAL_PUNCTUATION: ::libc::c_uint = 20;
pub const G_UNICODE_OTHER_PUNCTUATION: ::libc::c_uint = 21;
pub const G_UNICODE_OPEN_PUNCTUATION: ::libc::c_uint = 22;
pub const G_UNICODE_CURRENCY_SYMBOL: ::libc::c_uint = 23;
pub const G_UNICODE_MODIFIER_SYMBOL: ::libc::c_uint = 24;
pub const G_UNICODE_MATH_SYMBOL: ::libc::c_uint = 25;
pub const G_UNICODE_OTHER_SYMBOL: ::libc::c_uint = 26;
pub const G_UNICODE_LINE_SEPARATOR: ::libc::c_uint = 27;
pub const G_UNICODE_PARAGRAPH_SEPARATOR: ::libc::c_uint = 28;
pub const G_UNICODE_SPACE_SEPARATOR: ::libc::c_uint = 29;
pub type GUnicodeType = Enum_Unnamed54;
pub type Enum_Unnamed55 = ::libc::c_uint;
pub const G_UNICODE_BREAK_MANDATORY: ::libc::c_uint = 0;
pub const G_UNICODE_BREAK_CARRIAGE_RETURN: ::libc::c_uint = 1;
pub const G_UNICODE_BREAK_LINE_FEED: ::libc::c_uint = 2;
pub const G_UNICODE_BREAK_COMBINING_MARK: ::libc::c_uint = 3;
pub const G_UNICODE_BREAK_SURROGATE: ::libc::c_uint = 4;
pub const G_UNICODE_BREAK_ZERO_WIDTH_SPACE: ::libc::c_uint = 5;
pub const G_UNICODE_BREAK_INSEPARABLE: ::libc::c_uint = 6;
pub const G_UNICODE_BREAK_NON_BREAKING_GLUE: ::libc::c_uint = 7;
pub const G_UNICODE_BREAK_CONTINGENT: ::libc::c_uint = 8;
pub const G_UNICODE_BREAK_SPACE: ::libc::c_uint = 9;
pub const G_UNICODE_BREAK_AFTER: ::libc::c_uint = 10;
pub const G_UNICODE_BREAK_BEFORE: ::libc::c_uint = 11;
pub const G_UNICODE_BREAK_BEFORE_AND_AFTER: ::libc::c_uint = 12;
pub const G_UNICODE_BREAK_HYPHEN: ::libc::c_uint = 13;
pub const G_UNICODE_BREAK_NON_STARTER: ::libc::c_uint = 14;
pub const G_UNICODE_BREAK_OPEN_PUNCTUATION: ::libc::c_uint = 15;
pub const G_UNICODE_BREAK_CLOSE_PUNCTUATION: ::libc::c_uint = 16;
pub const G_UNICODE_BREAK_QUOTATION: ::libc::c_uint = 17;
pub const G_UNICODE_BREAK_EXCLAMATION: ::libc::c_uint = 18;
pub const G_UNICODE_BREAK_IDEOGRAPHIC: ::libc::c_uint = 19;
pub const G_UNICODE_BREAK_NUMERIC: ::libc::c_uint = 20;
pub const G_UNICODE_BREAK_INFIX_SEPARATOR: ::libc::c_uint = 21;
pub const G_UNICODE_BREAK_SYMBOL: ::libc::c_uint = 22;
pub const G_UNICODE_BREAK_ALPHABETIC: ::libc::c_uint = 23;
pub const G_UNICODE_BREAK_PREFIX: ::libc::c_uint = 24;
pub const G_UNICODE_BREAK_POSTFIX: ::libc::c_uint = 25;
pub const G_UNICODE_BREAK_COMPLEX_CONTEXT: ::libc::c_uint = 26;
pub const G_UNICODE_BREAK_AMBIGUOUS: ::libc::c_uint = 27;
pub const G_UNICODE_BREAK_UNKNOWN: ::libc::c_uint = 28;
pub const G_UNICODE_BREAK_NEXT_LINE: ::libc::c_uint = 29;
pub const G_UNICODE_BREAK_WORD_JOINER: ::libc::c_uint = 30;
pub const G_UNICODE_BREAK_HANGUL_L_JAMO: ::libc::c_uint = 31;
pub const G_UNICODE_BREAK_HANGUL_V_JAMO: ::libc::c_uint = 32;
pub const G_UNICODE_BREAK_HANGUL_T_JAMO: ::libc::c_uint = 33;
pub const G_UNICODE_BREAK_HANGUL_LV_SYLLABLE: ::libc::c_uint = 34;
pub const G_UNICODE_BREAK_HANGUL_LVT_SYLLABLE: ::libc::c_uint = 35;
pub const G_UNICODE_BREAK_CLOSE_PARANTHESIS: ::libc::c_uint = 36;
pub const G_UNICODE_BREAK_CONDITIONAL_JAPANESE_STARTER: ::libc::c_uint = 37;
pub const G_UNICODE_BREAK_HEBREW_LETTER: ::libc::c_uint = 38;
pub const G_UNICODE_BREAK_REGIONAL_INDICATOR: ::libc::c_uint = 39;
pub type GUnicodeBreakType = Enum_Unnamed55;
pub type Enum_Unnamed56 = ::libc::c_int;
pub const G_UNICODE_SCRIPT_INVALID_CODE: ::libc::c_int = -1;
pub const G_UNICODE_SCRIPT_COMMON: ::libc::c_int = 0;
pub const G_UNICODE_SCRIPT_INHERITED: ::libc::c_int = 1;
pub const G_UNICODE_SCRIPT_ARABIC: ::libc::c_int = 2;
pub const G_UNICODE_SCRIPT_ARMENIAN: ::libc::c_int = 3;
pub const G_UNICODE_SCRIPT_BENGALI: ::libc::c_int = 4;
pub const G_UNICODE_SCRIPT_BOPOMOFO: ::libc::c_int = 5;
pub const G_UNICODE_SCRIPT_CHEROKEE: ::libc::c_int = 6;
pub const G_UNICODE_SCRIPT_COPTIC: ::libc::c_int = 7;
pub const G_UNICODE_SCRIPT_CYRILLIC: ::libc::c_int = 8;
pub const G_UNICODE_SCRIPT_DESERET: ::libc::c_int = 9;
pub const G_UNICODE_SCRIPT_DEVANAGARI: ::libc::c_int = 10;
pub const G_UNICODE_SCRIPT_ETHIOPIC: ::libc::c_int = 11;
pub const G_UNICODE_SCRIPT_GEORGIAN: ::libc::c_int = 12;
pub const G_UNICODE_SCRIPT_GOTHIC: ::libc::c_int = 13;
pub const G_UNICODE_SCRIPT_GREEK: ::libc::c_int = 14;
pub const G_UNICODE_SCRIPT_GUJARATI: ::libc::c_int = 15;
pub const G_UNICODE_SCRIPT_GURMUKHI: ::libc::c_int = 16;
pub const G_UNICODE_SCRIPT_HAN: ::libc::c_int = 17;
pub const G_UNICODE_SCRIPT_HANGUL: ::libc::c_int = 18;
pub const G_UNICODE_SCRIPT_HEBREW: ::libc::c_int = 19;
pub const G_UNICODE_SCRIPT_HIRAGANA: ::libc::c_int = 20;
pub const G_UNICODE_SCRIPT_KANNADA: ::libc::c_int = 21;
pub const G_UNICODE_SCRIPT_KATAKANA: ::libc::c_int = 22;
pub const G_UNICODE_SCRIPT_KHMER: ::libc::c_int = 23;
pub const G_UNICODE_SCRIPT_LAO: ::libc::c_int = 24;
pub const G_UNICODE_SCRIPT_LATIN: ::libc::c_int = 25;
pub const G_UNICODE_SCRIPT_MALAYALAM: ::libc::c_int = 26;
pub const G_UNICODE_SCRIPT_MONGOLIAN: ::libc::c_int = 27;
pub const G_UNICODE_SCRIPT_MYANMAR: ::libc::c_int = 28;
pub const G_UNICODE_SCRIPT_OGHAM: ::libc::c_int = 29;
pub const G_UNICODE_SCRIPT_OLD_ITALIC: ::libc::c_int = 30;
pub const G_UNICODE_SCRIPT_ORIYA: ::libc::c_int = 31;
pub const G_UNICODE_SCRIPT_RUNIC: ::libc::c_int = 32;
pub const G_UNICODE_SCRIPT_SINHALA: ::libc::c_int = 33;
pub const G_UNICODE_SCRIPT_SYRIAC: ::libc::c_int = 34;
pub const G_UNICODE_SCRIPT_TAMIL: ::libc::c_int = 35;
pub const G_UNICODE_SCRIPT_TELUGU: ::libc::c_int = 36;
pub const G_UNICODE_SCRIPT_THAANA: ::libc::c_int = 37;
pub const G_UNICODE_SCRIPT_THAI: ::libc::c_int = 38;
pub const G_UNICODE_SCRIPT_TIBETAN: ::libc::c_int = 39;
pub const G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL: ::libc::c_int = 40;
pub const G_UNICODE_SCRIPT_YI: ::libc::c_int = 41;
pub const G_UNICODE_SCRIPT_TAGALOG: ::libc::c_int = 42;
pub const G_UNICODE_SCRIPT_HANUNOO: ::libc::c_int = 43;
pub const G_UNICODE_SCRIPT_BUHID: ::libc::c_int = 44;
pub const G_UNICODE_SCRIPT_TAGBANWA: ::libc::c_int = 45;
pub const G_UNICODE_SCRIPT_BRAILLE: ::libc::c_int = 46;
pub const G_UNICODE_SCRIPT_CYPRIOT: ::libc::c_int = 47;
pub const G_UNICODE_SCRIPT_LIMBU: ::libc::c_int = 48;
pub const G_UNICODE_SCRIPT_OSMANYA: ::libc::c_int = 49;
pub const G_UNICODE_SCRIPT_SHAVIAN: ::libc::c_int = 50;
pub const G_UNICODE_SCRIPT_LINEAR_B: ::libc::c_int = 51;
pub const G_UNICODE_SCRIPT_TAI_LE: ::libc::c_int = 52;
pub const G_UNICODE_SCRIPT_UGARITIC: ::libc::c_int = 53;
pub const G_UNICODE_SCRIPT_NEW_TAI_LUE: ::libc::c_int = 54;
pub const G_UNICODE_SCRIPT_BUGINESE: ::libc::c_int = 55;
pub const G_UNICODE_SCRIPT_GLAGOLITIC: ::libc::c_int = 56;
pub const G_UNICODE_SCRIPT_TIFINAGH: ::libc::c_int = 57;
pub const G_UNICODE_SCRIPT_SYLOTI_NAGRI: ::libc::c_int = 58;
pub const G_UNICODE_SCRIPT_OLD_PERSIAN: ::libc::c_int = 59;
pub const G_UNICODE_SCRIPT_KHAROSHTHI: ::libc::c_int = 60;
pub const G_UNICODE_SCRIPT_UNKNOWN: ::libc::c_int = 61;
pub const G_UNICODE_SCRIPT_BALINESE: ::libc::c_int = 62;
pub const G_UNICODE_SCRIPT_CUNEIFORM: ::libc::c_int = 63;
pub const G_UNICODE_SCRIPT_PHOENICIAN: ::libc::c_int = 64;
pub const G_UNICODE_SCRIPT_PHAGS_PA: ::libc::c_int = 65;
pub const G_UNICODE_SCRIPT_NKO: ::libc::c_int = 66;
pub const G_UNICODE_SCRIPT_KAYAH_LI: ::libc::c_int = 67;
pub const G_UNICODE_SCRIPT_LEPCHA: ::libc::c_int = 68;
pub const G_UNICODE_SCRIPT_REJANG: ::libc::c_int = 69;
pub const G_UNICODE_SCRIPT_SUNDANESE: ::libc::c_int = 70;
pub const G_UNICODE_SCRIPT_SAURASHTRA: ::libc::c_int = 71;
pub const G_UNICODE_SCRIPT_CHAM: ::libc::c_int = 72;
pub const G_UNICODE_SCRIPT_OL_CHIKI: ::libc::c_int = 73;
pub const G_UNICODE_SCRIPT_VAI: ::libc::c_int = 74;
pub const G_UNICODE_SCRIPT_CARIAN: ::libc::c_int = 75;
pub const G_UNICODE_SCRIPT_LYCIAN: ::libc::c_int = 76;
pub const G_UNICODE_SCRIPT_LYDIAN: ::libc::c_int = 77;
pub const G_UNICODE_SCRIPT_AVESTAN: ::libc::c_int = 78;
pub const G_UNICODE_SCRIPT_BAMUM: ::libc::c_int = 79;
pub const G_UNICODE_SCRIPT_EGYPTIAN_HIEROGLYPHS: ::libc::c_int = 80;
pub const G_UNICODE_SCRIPT_IMPERIAL_ARAMAIC: ::libc::c_int = 81;
pub const G_UNICODE_SCRIPT_INSCRIPTIONAL_PAHLAVI: ::libc::c_int = 82;
pub const G_UNICODE_SCRIPT_INSCRIPTIONAL_PARTHIAN: ::libc::c_int = 83;
pub const G_UNICODE_SCRIPT_JAVANESE: ::libc::c_int = 84;
pub const G_UNICODE_SCRIPT_KAITHI: ::libc::c_int = 85;
pub const G_UNICODE_SCRIPT_LISU: ::libc::c_int = 86;
pub const G_UNICODE_SCRIPT_MEETEI_MAYEK: ::libc::c_int = 87;
pub const G_UNICODE_SCRIPT_OLD_SOUTH_ARABIAN: ::libc::c_int = 88;
pub const G_UNICODE_SCRIPT_OLD_TURKIC: ::libc::c_int = 89;
pub const G_UNICODE_SCRIPT_SAMARITAN: ::libc::c_int = 90;
pub const G_UNICODE_SCRIPT_TAI_THAM: ::libc::c_int = 91;
pub const G_UNICODE_SCRIPT_TAI_VIET: ::libc::c_int = 92;
pub const G_UNICODE_SCRIPT_BATAK: ::libc::c_int = 93;
pub const G_UNICODE_SCRIPT_BRAHMI: ::libc::c_int = 94;
pub const G_UNICODE_SCRIPT_MANDAIC: ::libc::c_int = 95;
pub const G_UNICODE_SCRIPT_CHAKMA: ::libc::c_int = 96;
pub const G_UNICODE_SCRIPT_MEROITIC_CURSIVE: ::libc::c_int = 97;
pub const G_UNICODE_SCRIPT_MEROITIC_HIEROGLYPHS: ::libc::c_int = 98;
pub const G_UNICODE_SCRIPT_MIAO: ::libc::c_int = 99;
pub const G_UNICODE_SCRIPT_SHARADA: ::libc::c_int = 100;
pub const G_UNICODE_SCRIPT_SORA_SOMPENG: ::libc::c_int = 101;
pub const G_UNICODE_SCRIPT_TAKRI: ::libc::c_int = 102;
pub type GUnicodeScript = Enum_Unnamed56;
pub type Enum_Unnamed57 = ::libc::c_uint;
pub const G_NORMALIZE_DEFAULT: ::libc::c_uint = 0;
pub const G_NORMALIZE_NFD: ::libc::c_uint = 0;
pub const G_NORMALIZE_DEFAULT_COMPOSE: ::libc::c_uint = 1;
pub const G_NORMALIZE_NFC: ::libc::c_uint = 1;
pub const G_NORMALIZE_ALL: ::libc::c_uint = 2;
pub const G_NORMALIZE_NFKD: ::libc::c_uint = 2;
pub const G_NORMALIZE_ALL_COMPOSE: ::libc::c_uint = 3;
pub const G_NORMALIZE_NFKC: ::libc::c_uint = 3;
pub type GNormalizeMode = Enum_Unnamed57;
pub type Enum_Unnamed58 = ::libc::c_uint;
pub const G_USER_DIRECTORY_DESKTOP: ::libc::c_uint = 0;
pub const G_USER_DIRECTORY_DOCUMENTS: ::libc::c_uint = 1;
pub const G_USER_DIRECTORY_DOWNLOAD: ::libc::c_uint = 2;
pub const G_USER_DIRECTORY_MUSIC: ::libc::c_uint = 3;
pub const G_USER_DIRECTORY_PICTURES: ::libc::c_uint = 4;
pub const G_USER_DIRECTORY_PUBLIC_SHARE: ::libc::c_uint = 5;
pub const G_USER_DIRECTORY_TEMPLATES: ::libc::c_uint = 6;
pub const G_USER_DIRECTORY_VIDEOS: ::libc::c_uint = 7;
pub const G_USER_N_DIRECTORIES: ::libc::c_uint = 8;
pub type GUserDirectory = Enum_Unnamed58;
pub type GDebugKey = Struct__GDebugKey;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GDebugKey {
    pub key: *const gchar,
    pub value: guint,
}
impl ::std::clone::Clone for Struct__GDebugKey {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GDebugKey {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type Enum_Unnamed59 = ::libc::c_uint;
pub const G_FORMAT_SIZE_DEFAULT: ::libc::c_uint = 0;
pub const G_FORMAT_SIZE_LONG_FORMAT: ::libc::c_uint = 1;
pub const G_FORMAT_SIZE_IEC_UNITS: ::libc::c_uint = 2;
pub type GFormatSizeFlags = Enum_Unnamed59;
pub type GVoidFunc = ::std::option::Option<extern "C" fn() -> ()>;
pub type GString = Struct__GString;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GString {
    pub _str: *mut gchar,
    pub len: gsize,
    pub allocated_len: gsize,
}
impl ::std::clone::Clone for Struct__GString {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GString {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type GIOChannel = Struct__GIOChannel;
pub type GIOFuncs = Struct__GIOFuncs;
pub type Enum_Unnamed60 = ::libc::c_uint;
pub const G_IO_ERROR_NONE: ::libc::c_uint = 0;
pub const G_IO_ERROR_AGAIN: ::libc::c_uint = 1;
pub const G_IO_ERROR_INVAL: ::libc::c_uint = 2;
pub const G_IO_ERROR_UNKNOWN: ::libc::c_uint = 3;
pub type GIOError = Enum_Unnamed60;
pub type Enum_Unnamed61 = ::libc::c_uint;
pub const G_IO_CHANNEL_ERROR_FBIG: ::libc::c_uint = 0;
pub const G_IO_CHANNEL_ERROR_INVAL: ::libc::c_uint = 1;
pub const G_IO_CHANNEL_ERROR_IO: ::libc::c_uint = 2;
pub const G_IO_CHANNEL_ERROR_ISDIR: ::libc::c_uint = 3;
pub const G_IO_CHANNEL_ERROR_NOSPC: ::libc::c_uint = 4;
pub const G_IO_CHANNEL_ERROR_NXIO: ::libc::c_uint = 5;
pub const G_IO_CHANNEL_ERROR_OVERFLOW: ::libc::c_uint = 6;
pub const G_IO_CHANNEL_ERROR_PIPE: ::libc::c_uint = 7;
pub const G_IO_CHANNEL_ERROR_FAILED: ::libc::c_uint = 8;
pub type GIOChannelError = Enum_Unnamed61;
pub type Enum_Unnamed62 = ::libc::c_uint;
pub const G_IO_STATUS_ERROR: ::libc::c_uint = 0;
pub const G_IO_STATUS_NORMAL: ::libc::c_uint = 1;
pub const G_IO_STATUS_EOF: ::libc::c_uint = 2;
pub const G_IO_STATUS_AGAIN: ::libc::c_uint = 3;
pub type GIOStatus = Enum_Unnamed62;
pub type Enum_Unnamed63 = ::libc::c_uint;
pub const G_SEEK_CUR: ::libc::c_uint = 0;
pub const G_SEEK_SET: ::libc::c_uint = 1;
pub const G_SEEK_END: ::libc::c_uint = 2;
pub type GSeekType = Enum_Unnamed63;
pub type Enum_Unnamed64 = ::libc::c_uint;
pub const G_IO_FLAG_APPEND: ::libc::c_uint = 1;
pub const G_IO_FLAG_NONBLOCK: ::libc::c_uint = 2;
pub const G_IO_FLAG_IS_READABLE: ::libc::c_uint = 4;
pub const G_IO_FLAG_IS_WRITABLE: ::libc::c_uint = 8;
pub const G_IO_FLAG_IS_WRITEABLE: ::libc::c_uint = 8;
pub const G_IO_FLAG_IS_SEEKABLE: ::libc::c_uint = 16;
pub const G_IO_FLAG_MASK: ::libc::c_uint = 31;
pub const G_IO_FLAG_GET_MASK: ::libc::c_uint = 31;
pub const G_IO_FLAG_SET_MASK: ::libc::c_uint = 3;
pub type GIOFlags = Enum_Unnamed64;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GIOChannel {
    pub ref_count: gint,
    pub funcs: *mut GIOFuncs,
    pub encoding: *mut gchar,
    pub read_cd: GIConv,
    pub write_cd: GIConv,
    pub line_term: *mut gchar,
    pub line_term_len: guint,
    pub buf_size: gsize,
    pub read_buf: *mut GString,
    pub encoded_read_buf: *mut GString,
    pub write_buf: *mut GString,
    pub partial_write_buf: [gchar; 6usize],
    pub _bindgen_bitfield_1_: guint,
    pub _bindgen_bitfield_2_: guint,
    pub _bindgen_bitfield_3_: guint,
    pub _bindgen_bitfield_4_: guint,
    pub _bindgen_bitfield_5_: guint,
    pub _bindgen_bitfield_6_: guint,
    pub reserved1: gpointer,
    pub reserved2: gpointer,
}
impl ::std::clone::Clone for Struct__GIOChannel {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GIOChannel {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type GIOFunc =
    ::std::option::Option<extern "C" fn(source: *mut GIOChannel,
                                        condition: GIOCondition,
                                        data: gpointer) -> gboolean>;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GIOFuncs {
    pub io_read: ::std::option::Option<extern "C" fn(channel: *mut GIOChannel,
                                                     buf: *mut gchar,
                                                     count: gsize,
                                                     bytes_read: *mut gsize,
                                                     err: *mut *mut GError)
                                           -> GIOStatus>,
    pub io_write: ::std::option::Option<extern "C" fn(channel:
                                                          *mut GIOChannel,
                                                      buf: *const gchar,
                                                      count: gsize,
                                                      bytes_written:
                                                          *mut gsize,
                                                      err: *mut *mut GError)
                                            -> GIOStatus>,
    pub io_seek: ::std::option::Option<extern "C" fn(channel: *mut GIOChannel,
                                                     offset: gint64,
                                                     _type: GSeekType,
                                                     err: *mut *mut GError)
                                           -> GIOStatus>,
    pub io_close: ::std::option::Option<extern "C" fn(channel:
                                                          *mut GIOChannel,
                                                      err: *mut *mut GError)
                                            -> GIOStatus>,
    pub io_create_watch: ::std::option::Option<extern "C" fn(channel:
                                                                 *mut GIOChannel,
                                                             condition:
                                                                 GIOCondition)
                                                   -> *mut GSource>,
    pub io_free: ::std::option::Option<extern "C" fn(channel: *mut GIOChannel)
                                           -> ()>,
    pub io_set_flags: ::std::option::Option<extern "C" fn(channel:
                                                              *mut GIOChannel,
                                                          flags: GIOFlags,
                                                          err:
                                                              *mut *mut GError)
                                                -> GIOStatus>,
    pub io_get_flags: ::std::option::Option<extern "C" fn(channel:
                                                              *mut GIOChannel)
                                                -> GIOFlags>,
}
impl ::std::clone::Clone for Struct__GIOFuncs {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GIOFuncs {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type Enum_Unnamed65 = ::libc::c_uint;
pub const G_KEY_FILE_ERROR_UNKNOWN_ENCODING: ::libc::c_uint = 0;
pub const G_KEY_FILE_ERROR_PARSE: ::libc::c_uint = 1;
pub const G_KEY_FILE_ERROR_NOT_FOUND: ::libc::c_uint = 2;
pub const G_KEY_FILE_ERROR_KEY_NOT_FOUND: ::libc::c_uint = 3;
pub const G_KEY_FILE_ERROR_GROUP_NOT_FOUND: ::libc::c_uint = 4;
pub const G_KEY_FILE_ERROR_INVALID_VALUE: ::libc::c_uint = 5;
pub type GKeyFileError = Enum_Unnamed65;
pub enum Struct__GKeyFile { }
pub type GKeyFile = Struct__GKeyFile;
pub type Enum_Unnamed66 = ::libc::c_uint;
pub const G_KEY_FILE_NONE: ::libc::c_uint = 0;
pub const G_KEY_FILE_KEEP_COMMENTS: ::libc::c_uint = 1;
pub const G_KEY_FILE_KEEP_TRANSLATIONS: ::libc::c_uint = 2;
pub type GKeyFileFlags = Enum_Unnamed66;
pub enum Struct__GMappedFile { }
pub type GMappedFile = Struct__GMappedFile;
pub type Enum_Unnamed67 = ::libc::c_uint;
pub const G_MARKUP_ERROR_BAD_UTF8: ::libc::c_uint = 0;
pub const G_MARKUP_ERROR_EMPTY: ::libc::c_uint = 1;
pub const G_MARKUP_ERROR_PARSE: ::libc::c_uint = 2;
pub const G_MARKUP_ERROR_UNKNOWN_ELEMENT: ::libc::c_uint = 3;
pub const G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE: ::libc::c_uint = 4;
pub const G_MARKUP_ERROR_INVALID_CONTENT: ::libc::c_uint = 5;
pub const G_MARKUP_ERROR_MISSING_ATTRIBUTE: ::libc::c_uint = 6;
pub type GMarkupError = Enum_Unnamed67;
pub type Enum_Unnamed68 = ::libc::c_uint;
pub const G_MARKUP_DO_NOT_USE_THIS_UNSUPPORTED_FLAG: ::libc::c_uint = 1;
pub const G_MARKUP_TREAT_CDATA_AS_TEXT: ::libc::c_uint = 2;
pub const G_MARKUP_PREFIX_ERROR_POSITION: ::libc::c_uint = 4;
pub const G_MARKUP_IGNORE_QUALIFIED: ::libc::c_uint = 8;
pub type GMarkupParseFlags = Enum_Unnamed68;
pub enum Struct__GMarkupParseContext { }
pub type GMarkupParseContext = Struct__GMarkupParseContext;
pub type GMarkupParser = Struct__GMarkupParser;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GMarkupParser {
    pub start_element: ::std::option::Option<extern "C" fn(context:
                                                               *mut GMarkupParseContext,
                                                           element_name:
                                                               *const gchar,
                                                           attribute_names:
                                                               *mut *const gchar,
                                                           attribute_values:
                                                               *mut *const gchar,
                                                           user_data:
                                                               gpointer,
                                                           error:
                                                               *mut *mut GError)
                                                 -> ()>,
    pub end_element: ::std::option::Option<extern "C" fn(context:
                                                             *mut GMarkupParseContext,
                                                         element_name:
                                                             *const gchar,
                                                         user_data: gpointer,
                                                         error:
                                                             *mut *mut GError)
                                               -> ()>,
    pub text: ::std::option::Option<extern "C" fn(context:
                                                      *mut GMarkupParseContext,
                                                  text: *const gchar,
                                                  text_len: gsize,
                                                  user_data: gpointer,
                                                  error: *mut *mut GError)
                                        -> ()>,
    pub passthrough: ::std::option::Option<extern "C" fn(context:
                                                             *mut GMarkupParseContext,
                                                         passthrough_text:
                                                             *const gchar,
                                                         text_len: gsize,
                                                         user_data: gpointer,
                                                         error:
                                                             *mut *mut GError)
                                               -> ()>,
    pub error: ::std::option::Option<extern "C" fn(context:
                                                       *mut GMarkupParseContext,
                                                   error: *mut GError,
                                                   user_data: gpointer)
                                         -> ()>,
}
impl ::std::clone::Clone for Struct__GMarkupParser {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GMarkupParser {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type Enum_Unnamed69 = ::libc::c_uint;
pub const G_MARKUP_COLLECT_INVALID: ::libc::c_uint = 0;
pub const G_MARKUP_COLLECT_STRING: ::libc::c_uint = 1;
pub const G_MARKUP_COLLECT_STRDUP: ::libc::c_uint = 2;
pub const G_MARKUP_COLLECT_BOOLEAN: ::libc::c_uint = 3;
pub const G_MARKUP_COLLECT_TRISTATE: ::libc::c_uint = 4;
pub const G_MARKUP_COLLECT_OPTIONAL: ::libc::c_uint = 65536;
pub type GMarkupCollectType = Enum_Unnamed69;
pub type Enum_Unnamed70 = ::libc::c_int;
pub const G_LOG_FLAG_RECURSION: ::libc::c_int = 1;
pub const G_LOG_FLAG_FATAL: ::libc::c_int = 2;
pub const G_LOG_LEVEL_ERROR: ::libc::c_int = 4;
pub const G_LOG_LEVEL_CRITICAL: ::libc::c_int = 8;
pub const G_LOG_LEVEL_WARNING: ::libc::c_int = 16;
pub const G_LOG_LEVEL_MESSAGE: ::libc::c_int = 32;
pub const G_LOG_LEVEL_INFO: ::libc::c_int = 64;
pub const G_LOG_LEVEL_DEBUG: ::libc::c_int = 128;
pub const G_LOG_LEVEL_MASK: ::libc::c_int = -4;
pub type GLogLevelFlags = Enum_Unnamed70;
pub type GLogFunc =
    ::std::option::Option<extern "C" fn(log_domain: *const gchar,
                                        log_level: GLogLevelFlags,
                                        message: *const gchar,
                                        user_data: gpointer) -> ()>;
pub type GPrintFunc =
    ::std::option::Option<extern "C" fn(string: *const gchar) -> ()>;
pub enum Struct__GOptionContext { }
pub type GOptionContext = Struct__GOptionContext;
pub enum Struct__GOptionGroup { }
pub type GOptionGroup = Struct__GOptionGroup;
pub type GOptionEntry = Struct__GOptionEntry;
pub type Enum_Unnamed71 = ::libc::c_uint;
pub const G_OPTION_FLAG_HIDDEN: ::libc::c_uint = 1;
pub const G_OPTION_FLAG_IN_MAIN: ::libc::c_uint = 2;
pub const G_OPTION_FLAG_REVERSE: ::libc::c_uint = 4;
pub const G_OPTION_FLAG_NO_ARG: ::libc::c_uint = 8;
pub const G_OPTION_FLAG_FILENAME: ::libc::c_uint = 16;
pub const G_OPTION_FLAG_OPTIONAL_ARG: ::libc::c_uint = 32;
pub const G_OPTION_FLAG_NOALIAS: ::libc::c_uint = 64;
pub type GOptionFlags = Enum_Unnamed71;
pub type Enum_Unnamed72 = ::libc::c_uint;
pub const G_OPTION_ARG_NONE: ::libc::c_uint = 0;
pub const G_OPTION_ARG_STRING: ::libc::c_uint = 1;
pub const G_OPTION_ARG_INT: ::libc::c_uint = 2;
pub const G_OPTION_ARG_CALLBACK: ::libc::c_uint = 3;
pub const G_OPTION_ARG_FILENAME: ::libc::c_uint = 4;
pub const G_OPTION_ARG_STRING_ARRAY: ::libc::c_uint = 5;
pub const G_OPTION_ARG_FILENAME_ARRAY: ::libc::c_uint = 6;
pub const G_OPTION_ARG_DOUBLE: ::libc::c_uint = 7;
pub const G_OPTION_ARG_INT64: ::libc::c_uint = 8;
pub type GOptionArg = Enum_Unnamed72;
pub type GOptionArgFunc =
    ::std::option::Option<extern "C" fn(option_name: *const gchar,
                                        value: *const gchar, data: gpointer,
                                        error: *mut *mut GError) -> gboolean>;
pub type GOptionParseFunc =
    ::std::option::Option<extern "C" fn(context: *mut GOptionContext,
                                        group: *mut GOptionGroup,
                                        data: gpointer,
                                        error: *mut *mut GError) -> gboolean>;
pub type GOptionErrorFunc =
    ::std::option::Option<extern "C" fn(context: *mut GOptionContext,
                                        group: *mut GOptionGroup,
                                        data: gpointer,
                                        error: *mut *mut GError) -> ()>;
pub type Enum_Unnamed73 = ::libc::c_uint;
pub const G_OPTION_ERROR_UNKNOWN_OPTION: ::libc::c_uint = 0;
pub const G_OPTION_ERROR_BAD_VALUE: ::libc::c_uint = 1;
pub const G_OPTION_ERROR_FAILED: ::libc::c_uint = 2;
pub type GOptionError = Enum_Unnamed73;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GOptionEntry {
    pub long_name: *const gchar,
    pub short_name: gchar,
    pub flags: gint,
    pub arg: GOptionArg,
    pub arg_data: gpointer,
    pub description: *const gchar,
    pub arg_description: *const gchar,
}
impl ::std::clone::Clone for Struct__GOptionEntry {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GOptionEntry {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub enum Struct__GPatternSpec { }
pub type GPatternSpec = Struct__GPatternSpec;
pub type GQueue = Struct__GQueue;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GQueue {
    pub head: *mut GList,
    pub tail: *mut GList,
    pub length: guint,
}
impl ::std::clone::Clone for Struct__GQueue {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GQueue {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub enum Struct__GRand { }
pub type GRand = Struct__GRand;
pub type Enum_Unnamed74 = ::libc::c_uint;
pub const G_REGEX_ERROR_COMPILE: ::libc::c_uint = 0;
pub const G_REGEX_ERROR_OPTIMIZE: ::libc::c_uint = 1;
pub const G_REGEX_ERROR_REPLACE: ::libc::c_uint = 2;
pub const G_REGEX_ERROR_MATCH: ::libc::c_uint = 3;
pub const G_REGEX_ERROR_INTERNAL: ::libc::c_uint = 4;
pub const G_REGEX_ERROR_STRAY_BACKSLASH: ::libc::c_uint = 101;
pub const G_REGEX_ERROR_MISSING_CONTROL_CHAR: ::libc::c_uint = 102;
pub const G_REGEX_ERROR_UNRECOGNIZED_ESCAPE: ::libc::c_uint = 103;
pub const G_REGEX_ERROR_QUANTIFIERS_OUT_OF_ORDER: ::libc::c_uint = 104;
pub const G_REGEX_ERROR_QUANTIFIER_TOO_BIG: ::libc::c_uint = 105;
pub const G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS: ::libc::c_uint = 106;
pub const G_REGEX_ERROR_INVALID_ESCAPE_IN_CHARACTER_CLASS: ::libc::c_uint =
    107;
pub const G_REGEX_ERROR_RANGE_OUT_OF_ORDER: ::libc::c_uint = 108;
pub const G_REGEX_ERROR_NOTHING_TO_REPEAT: ::libc::c_uint = 109;
pub const G_REGEX_ERROR_UNRECOGNIZED_CHARACTER: ::libc::c_uint = 112;
pub const G_REGEX_ERROR_POSIX_NAMED_CLASS_OUTSIDE_CLASS: ::libc::c_uint = 113;
pub const G_REGEX_ERROR_UNMATCHED_PARENTHESIS: ::libc::c_uint = 114;
pub const G_REGEX_ERROR_INEXISTENT_SUBPATTERN_REFERENCE: ::libc::c_uint = 115;
pub const G_REGEX_ERROR_UNTERMINATED_COMMENT: ::libc::c_uint = 118;
pub const G_REGEX_ERROR_EXPRESSION_TOO_LARGE: ::libc::c_uint = 120;
pub const G_REGEX_ERROR_MEMORY_ERROR: ::libc::c_uint = 121;
pub const G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND: ::libc::c_uint = 125;
pub const G_REGEX_ERROR_MALFORMED_CONDITION: ::libc::c_uint = 126;
pub const G_REGEX_ERROR_TOO_MANY_CONDITIONAL_BRANCHES: ::libc::c_uint = 127;
pub const G_REGEX_ERROR_ASSERTION_EXPECTED: ::libc::c_uint = 128;
pub const G_REGEX_ERROR_UNKNOWN_POSIX_CLASS_NAME: ::libc::c_uint = 130;
pub const G_REGEX_ERROR_POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED: ::libc::c_uint
          =
    131;
pub const G_REGEX_ERROR_HEX_CODE_TOO_LARGE: ::libc::c_uint = 134;
pub const G_REGEX_ERROR_INVALID_CONDITION: ::libc::c_uint = 135;
pub const G_REGEX_ERROR_SINGLE_BYTE_MATCH_IN_LOOKBEHIND: ::libc::c_uint = 136;
pub const G_REGEX_ERROR_INFINITE_LOOP: ::libc::c_uint = 140;
pub const G_REGEX_ERROR_MISSING_SUBPATTERN_NAME_TERMINATOR: ::libc::c_uint =
    142;
pub const G_REGEX_ERROR_DUPLICATE_SUBPATTERN_NAME: ::libc::c_uint = 143;
pub const G_REGEX_ERROR_MALFORMED_PROPERTY: ::libc::c_uint = 146;
pub const G_REGEX_ERROR_UNKNOWN_PROPERTY: ::libc::c_uint = 147;
pub const G_REGEX_ERROR_SUBPATTERN_NAME_TOO_LONG: ::libc::c_uint = 148;
pub const G_REGEX_ERROR_TOO_MANY_SUBPATTERNS: ::libc::c_uint = 149;
pub const G_REGEX_ERROR_INVALID_OCTAL_VALUE: ::libc::c_uint = 151;
pub const G_REGEX_ERROR_TOO_MANY_BRANCHES_IN_DEFINE: ::libc::c_uint = 154;
pub const G_REGEX_ERROR_DEFINE_REPETION: ::libc::c_uint = 155;
pub const G_REGEX_ERROR_INCONSISTENT_NEWLINE_OPTIONS: ::libc::c_uint = 156;
pub const G_REGEX_ERROR_MISSING_BACK_REFERENCE: ::libc::c_uint = 157;
pub const G_REGEX_ERROR_INVALID_RELATIVE_REFERENCE: ::libc::c_uint = 158;
pub const G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_FORBIDDEN:
          ::libc::c_uint =
    159;
pub const G_REGEX_ERROR_UNKNOWN_BACKTRACKING_CONTROL_VERB: ::libc::c_uint =
    160;
pub const G_REGEX_ERROR_NUMBER_TOO_BIG: ::libc::c_uint = 161;
pub const G_REGEX_ERROR_MISSING_SUBPATTERN_NAME: ::libc::c_uint = 162;
pub const G_REGEX_ERROR_MISSING_DIGIT: ::libc::c_uint = 163;
pub const G_REGEX_ERROR_INVALID_DATA_CHARACTER: ::libc::c_uint = 164;
pub const G_REGEX_ERROR_EXTRA_SUBPATTERN_NAME: ::libc::c_uint = 165;
pub const G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED:
          ::libc::c_uint =
    166;
pub const G_REGEX_ERROR_INVALID_CONTROL_CHAR: ::libc::c_uint = 168;
pub const G_REGEX_ERROR_MISSING_NAME: ::libc::c_uint = 169;
pub const G_REGEX_ERROR_NOT_SUPPORTED_IN_CLASS: ::libc::c_uint = 171;
pub const G_REGEX_ERROR_TOO_MANY_FORWARD_REFERENCES: ::libc::c_uint = 172;
pub const G_REGEX_ERROR_NAME_TOO_LONG: ::libc::c_uint = 175;
pub const G_REGEX_ERROR_CHARACTER_VALUE_TOO_LARGE: ::libc::c_uint = 176;
pub type GRegexError = Enum_Unnamed74;
pub type Enum_Unnamed75 = ::libc::c_uint;
pub const G_REGEX_CASELESS: ::libc::c_uint = 1;
pub const G_REGEX_MULTILINE: ::libc::c_uint = 2;
pub const G_REGEX_DOTALL: ::libc::c_uint = 4;
pub const G_REGEX_EXTENDED: ::libc::c_uint = 8;
pub const G_REGEX_ANCHORED: ::libc::c_uint = 16;
pub const G_REGEX_DOLLAR_ENDONLY: ::libc::c_uint = 32;
pub const G_REGEX_UNGREEDY: ::libc::c_uint = 512;
pub const G_REGEX_RAW: ::libc::c_uint = 2048;
pub const G_REGEX_NO_AUTO_CAPTURE: ::libc::c_uint = 4096;
pub const G_REGEX_OPTIMIZE: ::libc::c_uint = 8192;
pub const G_REGEX_FIRSTLINE: ::libc::c_uint = 262144;
pub const G_REGEX_DUPNAMES: ::libc::c_uint = 524288;
pub const G_REGEX_NEWLINE_CR: ::libc::c_uint = 1048576;
pub const G_REGEX_NEWLINE_LF: ::libc::c_uint = 2097152;
pub const G_REGEX_NEWLINE_CRLF: ::libc::c_uint = 3145728;
pub const G_REGEX_NEWLINE_ANYCRLF: ::libc::c_uint = 5242880;
pub const G_REGEX_BSR_ANYCRLF: ::libc::c_uint = 8388608;
pub const G_REGEX_JAVASCRIPT_COMPAT: ::libc::c_uint = 33554432;
pub type GRegexCompileFlags = Enum_Unnamed75;
pub type Enum_Unnamed76 = ::libc::c_uint;
pub const G_REGEX_MATCH_ANCHORED: ::libc::c_uint = 16;
pub const G_REGEX_MATCH_NOTBOL: ::libc::c_uint = 128;
pub const G_REGEX_MATCH_NOTEOL: ::libc::c_uint = 256;
pub const G_REGEX_MATCH_NOTEMPTY: ::libc::c_uint = 1024;
pub const G_REGEX_MATCH_PARTIAL: ::libc::c_uint = 32768;
pub const G_REGEX_MATCH_NEWLINE_CR: ::libc::c_uint = 1048576;
pub const G_REGEX_MATCH_NEWLINE_LF: ::libc::c_uint = 2097152;
pub const G_REGEX_MATCH_NEWLINE_CRLF: ::libc::c_uint = 3145728;
pub const G_REGEX_MATCH_NEWLINE_ANY: ::libc::c_uint = 4194304;
pub const G_REGEX_MATCH_NEWLINE_ANYCRLF: ::libc::c_uint = 5242880;
pub const G_REGEX_MATCH_BSR_ANYCRLF: ::libc::c_uint = 8388608;
pub const G_REGEX_MATCH_BSR_ANY: ::libc::c_uint = 16777216;
pub const G_REGEX_MATCH_PARTIAL_SOFT: ::libc::c_uint = 32768;
pub const G_REGEX_MATCH_PARTIAL_HARD: ::libc::c_uint = 134217728;
pub const G_REGEX_MATCH_NOTEMPTY_ATSTART: ::libc::c_uint = 268435456;
pub type GRegexMatchFlags = Enum_Unnamed76;
pub enum Struct__GRegex { }
pub type GRegex = Struct__GRegex;
pub enum Struct__GMatchInfo { }
pub type GMatchInfo = Struct__GMatchInfo;
pub type GRegexEvalCallback =
    ::std::option::Option<extern "C" fn(match_info: *const GMatchInfo,
                                        result: *mut GString,
                                        user_data: gpointer) -> gboolean>;
pub type GScanner = Struct__GScanner;
pub type GScannerConfig = Struct__GScannerConfig;
pub type GTokenValue = Union__GTokenValue;
pub type GScannerMsgFunc =
    ::std::option::Option<extern "C" fn(scanner: *mut GScanner,
                                        message: *mut gchar, error: gboolean)
                              -> ()>;
pub type Enum_Unnamed77 = ::libc::c_uint;
pub const G_ERR_UNKNOWN: ::libc::c_uint = 0;
pub const G_ERR_UNEXP_EOF: ::libc::c_uint = 1;
pub const G_ERR_UNEXP_EOF_IN_STRING: ::libc::c_uint = 2;
pub const G_ERR_UNEXP_EOF_IN_COMMENT: ::libc::c_uint = 3;
pub const G_ERR_NON_DIGIT_IN_CONST: ::libc::c_uint = 4;
pub const G_ERR_DIGIT_RADIX: ::libc::c_uint = 5;
pub const G_ERR_FLOAT_RADIX: ::libc::c_uint = 6;
pub const G_ERR_FLOAT_MALFORMED: ::libc::c_uint = 7;
pub type GErrorType = Enum_Unnamed77;
pub type Enum_Unnamed78 = ::libc::c_uint;
pub const G_TOKEN_EOF: ::libc::c_uint = 0;
pub const G_TOKEN_LEFT_PAREN: ::libc::c_uint = 40;
pub const G_TOKEN_RIGHT_PAREN: ::libc::c_uint = 41;
pub const G_TOKEN_LEFT_CURLY: ::libc::c_uint = 123;
pub const G_TOKEN_RIGHT_CURLY: ::libc::c_uint = 125;
pub const G_TOKEN_LEFT_BRACE: ::libc::c_uint = 91;
pub const G_TOKEN_RIGHT_BRACE: ::libc::c_uint = 93;
pub const G_TOKEN_EQUAL_SIGN: ::libc::c_uint = 61;
pub const G_TOKEN_COMMA: ::libc::c_uint = 44;
pub const G_TOKEN_NONE: ::libc::c_uint = 256;
pub const G_TOKEN_ERROR: ::libc::c_uint = 257;
pub const G_TOKEN_CHAR: ::libc::c_uint = 258;
pub const G_TOKEN_BINARY: ::libc::c_uint = 259;
pub const G_TOKEN_OCTAL: ::libc::c_uint = 260;
pub const G_TOKEN_INT: ::libc::c_uint = 261;
pub const G_TOKEN_HEX: ::libc::c_uint = 262;
pub const G_TOKEN_FLOAT: ::libc::c_uint = 263;
pub const G_TOKEN_STRING: ::libc::c_uint = 264;
pub const G_TOKEN_SYMBOL: ::libc::c_uint = 265;
pub const G_TOKEN_IDENTIFIER: ::libc::c_uint = 266;
pub const G_TOKEN_IDENTIFIER_NULL: ::libc::c_uint = 267;
pub const G_TOKEN_COMMENT_SINGLE: ::libc::c_uint = 268;
pub const G_TOKEN_COMMENT_MULTI: ::libc::c_uint = 269;
pub const G_TOKEN_LAST: ::libc::c_uint = 270;
pub type GTokenType = Enum_Unnamed78;
#[repr(C)]
#[derive(Copy)]
pub struct Union__GTokenValue {
    pub _bindgen_data_: [u64; 1usize],
}
impl Union__GTokenValue {
    pub unsafe fn v_symbol(&mut self) -> *mut gpointer {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn v_identifier(&mut self) -> *mut *mut gchar {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn v_binary(&mut self) -> *mut gulong {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn v_octal(&mut self) -> *mut gulong {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn v_int(&mut self) -> *mut gulong {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn v_int64(&mut self) -> *mut guint64 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn v_float(&mut self) -> *mut gdouble {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn v_hex(&mut self) -> *mut gulong {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn v_string(&mut self) -> *mut *mut gchar {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn v_comment(&mut self) -> *mut *mut gchar {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn v_char(&mut self) -> *mut guchar {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn v_error(&mut self) -> *mut guint {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union__GTokenValue {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union__GTokenValue {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GScannerConfig {
    pub cset_skip_characters: *mut gchar,
    pub cset_identifier_first: *mut gchar,
    pub cset_identifier_nth: *mut gchar,
    pub cpair_comment_single: *mut gchar,
    pub _bindgen_bitfield_1_: guint,
    pub _bindgen_bitfield_2_: guint,
    pub _bindgen_bitfield_3_: guint,
    pub _bindgen_bitfield_4_: guint,
    pub _bindgen_bitfield_5_: guint,
    pub _bindgen_bitfield_6_: guint,
    pub _bindgen_bitfield_7_: guint,
    pub _bindgen_bitfield_8_: guint,
    pub _bindgen_bitfield_9_: guint,
    pub _bindgen_bitfield_10_: guint,
    pub _bindgen_bitfield_11_: guint,
    pub _bindgen_bitfield_12_: guint,
    pub _bindgen_bitfield_13_: guint,
    pub _bindgen_bitfield_14_: guint,
    pub _bindgen_bitfield_15_: guint,
    pub _bindgen_bitfield_16_: guint,
    pub _bindgen_bitfield_17_: guint,
    pub _bindgen_bitfield_18_: guint,
    pub _bindgen_bitfield_19_: guint,
    pub _bindgen_bitfield_20_: guint,
    pub _bindgen_bitfield_21_: guint,
    pub _bindgen_bitfield_22_: guint,
    pub padding_dummy: guint,
}
impl ::std::clone::Clone for Struct__GScannerConfig {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GScannerConfig {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GScanner {
    pub user_data: gpointer,
    pub max_parse_errors: guint,
    pub parse_errors: guint,
    pub input_name: *const gchar,
    pub qdata: *mut GData,
    pub config: *mut GScannerConfig,
    pub token: GTokenType,
    pub value: GTokenValue,
    pub line: guint,
    pub position: guint,
    pub next_token: GTokenType,
    pub next_value: GTokenValue,
    pub next_line: guint,
    pub next_position: guint,
    pub symbol_table: *mut GHashTable,
    pub input_fd: gint,
    pub text: *const gchar,
    pub text_end: *const gchar,
    pub buffer: *mut gchar,
    pub scope_id: guint,
    pub msg_handler: GScannerMsgFunc,
}
impl ::std::clone::Clone for Struct__GScanner {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GScanner {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub enum Struct__GSequence { }
pub type GSequence = Struct__GSequence;
pub enum Struct__GSequenceNode { }
pub type GSequenceIter = Struct__GSequenceNode;
pub type GSequenceIterCompareFunc =
    ::std::option::Option<extern "C" fn(a: *mut GSequenceIter,
                                        b: *mut GSequenceIter, data: gpointer)
                              -> gint>;
pub type Enum_Unnamed79 = ::libc::c_uint;
pub const G_SHELL_ERROR_BAD_QUOTING: ::libc::c_uint = 0;
pub const G_SHELL_ERROR_EMPTY_STRING: ::libc::c_uint = 1;
pub const G_SHELL_ERROR_FAILED: ::libc::c_uint = 2;
pub type GShellError = Enum_Unnamed79;
pub type Enum_Unnamed80 = ::libc::c_uint;
pub const G_SLICE_CONFIG_ALWAYS_MALLOC: ::libc::c_uint = 1;
pub const G_SLICE_CONFIG_BYPASS_MAGAZINES: ::libc::c_uint = 2;
pub const G_SLICE_CONFIG_WORKING_SET_MSECS: ::libc::c_uint = 3;
pub const G_SLICE_CONFIG_COLOR_INCREMENT: ::libc::c_uint = 4;
pub const G_SLICE_CONFIG_CHUNK_SIZES: ::libc::c_uint = 5;
pub const G_SLICE_CONFIG_CONTENTION_COUNTER: ::libc::c_uint = 6;
pub type GSliceConfig = Enum_Unnamed80;
pub type Enum_Unnamed81 = ::libc::c_uint;
pub const G_SPAWN_ERROR_FORK: ::libc::c_uint = 0;
pub const G_SPAWN_ERROR_READ: ::libc::c_uint = 1;
pub const G_SPAWN_ERROR_CHDIR: ::libc::c_uint = 2;
pub const G_SPAWN_ERROR_ACCES: ::libc::c_uint = 3;
pub const G_SPAWN_ERROR_PERM: ::libc::c_uint = 4;
pub const G_SPAWN_ERROR_TOO_BIG: ::libc::c_uint = 5;
pub const G_SPAWN_ERROR_2BIG: ::libc::c_uint = 5;
pub const G_SPAWN_ERROR_NOEXEC: ::libc::c_uint = 6;
pub const G_SPAWN_ERROR_NAMETOOLONG: ::libc::c_uint = 7;
pub const G_SPAWN_ERROR_NOENT: ::libc::c_uint = 8;
pub const G_SPAWN_ERROR_NOMEM: ::libc::c_uint = 9;
pub const G_SPAWN_ERROR_NOTDIR: ::libc::c_uint = 10;
pub const G_SPAWN_ERROR_LOOP: ::libc::c_uint = 11;
pub const G_SPAWN_ERROR_TXTBUSY: ::libc::c_uint = 12;
pub const G_SPAWN_ERROR_IO: ::libc::c_uint = 13;
pub const G_SPAWN_ERROR_NFILE: ::libc::c_uint = 14;
pub const G_SPAWN_ERROR_MFILE: ::libc::c_uint = 15;
pub const G_SPAWN_ERROR_INVAL: ::libc::c_uint = 16;
pub const G_SPAWN_ERROR_ISDIR: ::libc::c_uint = 17;
pub const G_SPAWN_ERROR_LIBBAD: ::libc::c_uint = 18;
pub const G_SPAWN_ERROR_FAILED: ::libc::c_uint = 19;
pub type GSpawnError = Enum_Unnamed81;
pub type GSpawnChildSetupFunc =
    ::std::option::Option<extern "C" fn(user_data: gpointer) -> ()>;
pub type Enum_Unnamed82 = ::libc::c_uint;
pub const G_SPAWN_DEFAULT: ::libc::c_uint = 0;
pub const G_SPAWN_LEAVE_DESCRIPTORS_OPEN: ::libc::c_uint = 1;
pub const G_SPAWN_DO_NOT_REAP_CHILD: ::libc::c_uint = 2;
pub const G_SPAWN_SEARCH_PATH: ::libc::c_uint = 4;
pub const G_SPAWN_STDOUT_TO_DEV_NULL: ::libc::c_uint = 8;
pub const G_SPAWN_STDERR_TO_DEV_NULL: ::libc::c_uint = 16;
pub const G_SPAWN_CHILD_INHERITS_STDIN: ::libc::c_uint = 32;
pub const G_SPAWN_FILE_AND_ARGV_ZERO: ::libc::c_uint = 64;
pub const G_SPAWN_SEARCH_PATH_FROM_ENVP: ::libc::c_uint = 128;
pub const G_SPAWN_CLOEXEC_PIPES: ::libc::c_uint = 256;
pub type GSpawnFlags = Enum_Unnamed82;
pub type Enum_Unnamed83 = ::libc::c_uint;
pub const G_ASCII_ALNUM: ::libc::c_uint = 1;
pub const G_ASCII_ALPHA: ::libc::c_uint = 2;
pub const G_ASCII_CNTRL: ::libc::c_uint = 4;
pub const G_ASCII_DIGIT: ::libc::c_uint = 8;
pub const G_ASCII_GRAPH: ::libc::c_uint = 16;
pub const G_ASCII_LOWER: ::libc::c_uint = 32;
pub const G_ASCII_PRINT: ::libc::c_uint = 64;
pub const G_ASCII_PUNCT: ::libc::c_uint = 128;
pub const G_ASCII_SPACE: ::libc::c_uint = 256;
pub const G_ASCII_UPPER: ::libc::c_uint = 512;
pub const G_ASCII_XDIGIT: ::libc::c_uint = 1024;
pub type GAsciiType = Enum_Unnamed83;
pub enum Struct__GStringChunk { }
pub type GStringChunk = Struct__GStringChunk;
pub enum Struct_GTestCase { }
pub type GTestCase = Struct_GTestCase;
pub enum Struct_GTestSuite { }
pub type GTestSuite = Struct_GTestSuite;
pub type GTestFunc = ::std::option::Option<extern "C" fn() -> ()>;
pub type GTestDataFunc =
    ::std::option::Option<extern "C" fn(user_data: gconstpointer) -> ()>;
pub type GTestFixtureFunc =
    ::std::option::Option<extern "C" fn(fixture: gpointer,
                                        user_data: gconstpointer) -> ()>;
pub type Enum_Unnamed84 = ::libc::c_uint;
pub const G_TEST_TRAP_SILENCE_STDOUT: ::libc::c_uint = 128;
pub const G_TEST_TRAP_SILENCE_STDERR: ::libc::c_uint = 256;
pub const G_TEST_TRAP_INHERIT_STDIN: ::libc::c_uint = 512;
pub type GTestTrapFlags = Enum_Unnamed84;
pub type Enum_Unnamed85 = ::libc::c_uint;
pub const G_TEST_SUBPROCESS_INHERIT_STDIN: ::libc::c_uint = 1;
pub const G_TEST_SUBPROCESS_INHERIT_STDOUT: ::libc::c_uint = 2;
pub const G_TEST_SUBPROCESS_INHERIT_STDERR: ::libc::c_uint = 4;
pub type GTestSubprocessFlags = Enum_Unnamed85;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed86 {
    pub test_initialized: gboolean,
    pub test_quick: gboolean,
    pub test_perf: gboolean,
    pub test_verbose: gboolean,
    pub test_quiet: gboolean,
    pub test_undefined: gboolean,
}
impl ::std::clone::Clone for Struct_Unnamed86 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed86 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type GTestConfig = Struct_Unnamed86;
pub type Enum_Unnamed87 = ::libc::c_uint;
pub const G_TEST_LOG_NONE: ::libc::c_uint = 0;
pub const G_TEST_LOG_ERROR: ::libc::c_uint = 1;
pub const G_TEST_LOG_START_BINARY: ::libc::c_uint = 2;
pub const G_TEST_LOG_LIST_CASE: ::libc::c_uint = 3;
pub const G_TEST_LOG_SKIP_CASE: ::libc::c_uint = 4;
pub const G_TEST_LOG_START_CASE: ::libc::c_uint = 5;
pub const G_TEST_LOG_STOP_CASE: ::libc::c_uint = 6;
pub const G_TEST_LOG_MIN_RESULT: ::libc::c_uint = 7;
pub const G_TEST_LOG_MAX_RESULT: ::libc::c_uint = 8;
pub const G_TEST_LOG_MESSAGE: ::libc::c_uint = 9;
pub const G_TEST_LOG_START_SUITE: ::libc::c_uint = 10;
pub const G_TEST_LOG_STOP_SUITE: ::libc::c_uint = 11;
pub type GTestLogType = Enum_Unnamed87;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed88 {
    pub log_type: GTestLogType,
    pub n_strings: guint,
    pub strings: *mut *mut gchar,
    pub n_nums: guint,
    pub nums: *mut ::libc::c_double,
}
impl ::std::clone::Clone for Struct_Unnamed88 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed88 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type GTestLogMsg = Struct_Unnamed88;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed89 {
    pub data: *mut GString,
    pub msgs: *mut GSList,
}
impl ::std::clone::Clone for Struct_Unnamed89 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed89 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type GTestLogBuffer = Struct_Unnamed89;
pub type GTestLogFatalFunc =
    ::std::option::Option<extern "C" fn(log_domain: *const gchar,
                                        log_level: GLogLevelFlags,
                                        message: *const gchar,
                                        user_data: gpointer) -> gboolean>;
pub type Enum_Unnamed90 = ::libc::c_uint;
pub const G_TEST_DIST: ::libc::c_uint = 0;
pub const G_TEST_BUILT: ::libc::c_uint = 1;
pub type GTestFileType = Enum_Unnamed90;
pub type GThreadPool = Struct__GThreadPool;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GThreadPool {
    pub func: GFunc,
    pub user_data: gpointer,
    pub exclusive: gboolean,
}
impl ::std::clone::Clone for Struct__GThreadPool {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GThreadPool {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub enum Struct__GTimer { }
pub type GTimer = Struct__GTimer;
pub type GTrashStack = Struct__GTrashStack;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GTrashStack {
    pub next: *mut GTrashStack,
}
impl ::std::clone::Clone for Struct__GTrashStack {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GTrashStack {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub enum Struct__GTree { }
pub type GTree = Struct__GTree;
pub type GTraverseFunc =
    ::std::option::Option<extern "C" fn(key: gpointer, value: gpointer,
                                        data: gpointer) -> gboolean>;
pub enum Struct__GVariantType { }
pub type GVariantType = Struct__GVariantType;
pub enum Struct__GVariant { }
pub type GVariant = Struct__GVariant;
pub type Enum_Unnamed91 = ::libc::c_uint;
pub const G_VARIANT_CLASS_BOOLEAN: ::libc::c_uint = 98;
pub const G_VARIANT_CLASS_BYTE: ::libc::c_uint = 121;
pub const G_VARIANT_CLASS_INT16: ::libc::c_uint = 110;
pub const G_VARIANT_CLASS_UINT16: ::libc::c_uint = 113;
pub const G_VARIANT_CLASS_INT32: ::libc::c_uint = 105;
pub const G_VARIANT_CLASS_UINT32: ::libc::c_uint = 117;
pub const G_VARIANT_CLASS_INT64: ::libc::c_uint = 120;
pub const G_VARIANT_CLASS_UINT64: ::libc::c_uint = 116;
pub const G_VARIANT_CLASS_HANDLE: ::libc::c_uint = 104;
pub const G_VARIANT_CLASS_DOUBLE: ::libc::c_uint = 100;
pub const G_VARIANT_CLASS_STRING: ::libc::c_uint = 115;
pub const G_VARIANT_CLASS_OBJECT_PATH: ::libc::c_uint = 111;
pub const G_VARIANT_CLASS_SIGNATURE: ::libc::c_uint = 103;
pub const G_VARIANT_CLASS_VARIANT: ::libc::c_uint = 118;
pub const G_VARIANT_CLASS_MAYBE: ::libc::c_uint = 109;
pub const G_VARIANT_CLASS_ARRAY: ::libc::c_uint = 97;
pub const G_VARIANT_CLASS_TUPLE: ::libc::c_uint = 40;
pub const G_VARIANT_CLASS_DICT_ENTRY: ::libc::c_uint = 123;
pub type GVariantClass = Enum_Unnamed91;
pub type GVariantIter = Struct__GVariantIter;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GVariantIter {
    pub x: [gsize; 16usize],
}
impl ::std::clone::Clone for Struct__GVariantIter {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GVariantIter {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type GVariantBuilder = Struct__GVariantBuilder;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GVariantBuilder {
    pub x: [gsize; 16usize],
}
impl ::std::clone::Clone for Struct__GVariantBuilder {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GVariantBuilder {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type Enum_Unnamed92 = ::libc::c_uint;
pub const G_VARIANT_PARSE_ERROR_FAILED: ::libc::c_uint = 0;
pub const G_VARIANT_PARSE_ERROR_BASIC_TYPE_EXPECTED: ::libc::c_uint = 1;
pub const G_VARIANT_PARSE_ERROR_CANNOT_INFER_TYPE: ::libc::c_uint = 2;
pub const G_VARIANT_PARSE_ERROR_DEFINITE_TYPE_EXPECTED: ::libc::c_uint = 3;
pub const G_VARIANT_PARSE_ERROR_INPUT_NOT_AT_END: ::libc::c_uint = 4;
pub const G_VARIANT_PARSE_ERROR_INVALID_CHARACTER: ::libc::c_uint = 5;
pub const G_VARIANT_PARSE_ERROR_INVALID_FORMAT_STRING: ::libc::c_uint = 6;
pub const G_VARIANT_PARSE_ERROR_INVALID_OBJECT_PATH: ::libc::c_uint = 7;
pub const G_VARIANT_PARSE_ERROR_INVALID_SIGNATURE: ::libc::c_uint = 8;
pub const G_VARIANT_PARSE_ERROR_INVALID_TYPE_STRING: ::libc::c_uint = 9;
pub const G_VARIANT_PARSE_ERROR_NO_COMMON_TYPE: ::libc::c_uint = 10;
pub const G_VARIANT_PARSE_ERROR_NUMBER_OUT_OF_RANGE: ::libc::c_uint = 11;
pub const G_VARIANT_PARSE_ERROR_NUMBER_TOO_BIG: ::libc::c_uint = 12;
pub const G_VARIANT_PARSE_ERROR_TYPE_ERROR: ::libc::c_uint = 13;
pub const G_VARIANT_PARSE_ERROR_UNEXPECTED_TOKEN: ::libc::c_uint = 14;
pub const G_VARIANT_PARSE_ERROR_UNKNOWN_KEYWORD: ::libc::c_uint = 15;
pub const G_VARIANT_PARSE_ERROR_UNTERMINATED_STRING_CONSTANT: ::libc::c_uint =
    16;
pub const G_VARIANT_PARSE_ERROR_VALUE_EXPECTED: ::libc::c_uint = 17;
pub type GVariantParseError = Enum_Unnamed92;
pub type GVariantDict = Struct__GVariantDict;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GVariantDict {
    pub x: [gsize; 16usize],
}
impl ::std::clone::Clone for Struct__GVariantDict {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GVariantDict {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub enum Struct__GAllocator { }
pub type GAllocator = Struct__GAllocator;
pub enum Struct__GMemChunk { }
pub type GMemChunk = Struct__GMemChunk;
pub enum Struct__GCache { }
pub type GCache = Struct__GCache;
pub type GCacheNewFunc =
    ::std::option::Option<extern "C" fn(key: gpointer) -> gpointer>;
pub type GCacheDupFunc =
    ::std::option::Option<extern "C" fn(value: gpointer) -> gpointer>;
pub type GCacheDestroyFunc =
    ::std::option::Option<extern "C" fn(value: gpointer) -> ()>;
pub type GCompletion = Struct__GCompletion;
pub type GCompletionFunc =
    ::std::option::Option<extern "C" fn(arg1: gpointer) -> *mut gchar>;
pub type GCompletionStrncmpFunc =
    ::std::option::Option<extern "C" fn(s1: *const gchar, s2: *const gchar,
                                        n: gsize) -> gint>;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GCompletion {
    pub items: *mut GList,
    pub func: GCompletionFunc,
    pub prefix: *mut gchar,
    pub cache: *mut GList,
    pub strncmp_func: GCompletionStrncmpFunc,
}
impl ::std::clone::Clone for Struct__GCompletion {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GCompletion {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub enum Struct__GRelation { }
pub type GRelation = Struct__GRelation;
pub type GTuples = Struct__GTuples;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GTuples {
    pub len: guint,
}
impl ::std::clone::Clone for Struct__GTuples {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GTuples {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type Enum_Unnamed93 = ::libc::c_uint;
pub const G_THREAD_PRIORITY_LOW: ::libc::c_uint = 0;
pub const G_THREAD_PRIORITY_NORMAL: ::libc::c_uint = 1;
pub const G_THREAD_PRIORITY_HIGH: ::libc::c_uint = 2;
pub const G_THREAD_PRIORITY_URGENT: ::libc::c_uint = 3;
pub type GThreadPriority = Enum_Unnamed93;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GThread {
    pub func: GThreadFunc,
    pub data: gpointer,
    pub joinable: gboolean,
    pub priority: GThreadPriority,
}
impl ::std::clone::Clone for Struct__GThread {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GThread {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type GThreadFunctions = Struct__GThreadFunctions;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GThreadFunctions {
    pub mutex_new: ::std::option::Option<extern "C" fn() -> *mut GMutex>,
    pub mutex_lock: ::std::option::Option<extern "C" fn(mutex: *mut GMutex)
                                              -> ()>,
    pub mutex_trylock: ::std::option::Option<extern "C" fn(mutex: *mut GMutex)
                                                 -> gboolean>,
    pub mutex_unlock: ::std::option::Option<extern "C" fn(mutex: *mut GMutex)
                                                -> ()>,
    pub mutex_free: ::std::option::Option<extern "C" fn(mutex: *mut GMutex)
                                              -> ()>,
    pub cond_new: ::std::option::Option<extern "C" fn() -> *mut GCond>,
    pub cond_signal: ::std::option::Option<extern "C" fn(cond: *mut GCond)
                                               -> ()>,
    pub cond_broadcast: ::std::option::Option<extern "C" fn(cond: *mut GCond)
                                                  -> ()>,
    pub cond_wait: ::std::option::Option<extern "C" fn(cond: *mut GCond,
                                                       mutex: *mut GMutex)
                                             -> ()>,
    pub cond_timed_wait: ::std::option::Option<extern "C" fn(cond: *mut GCond,
                                                             mutex:
                                                                 *mut GMutex,
                                                             end_time:
                                                                 *mut GTimeVal)
                                                   -> gboolean>,
    pub cond_free: ::std::option::Option<extern "C" fn(cond: *mut GCond)
                                             -> ()>,
    pub private_new: ::std::option::Option<extern "C" fn(destructor:
                                                             GDestroyNotify)
                                               -> *mut GPrivate>,
    pub private_get: ::std::option::Option<extern "C" fn(private_key:
                                                             *mut GPrivate)
                                               -> gpointer>,
    pub private_set: ::std::option::Option<extern "C" fn(private_key:
                                                             *mut GPrivate,
                                                         data: gpointer)
                                               -> ()>,
    pub thread_create: ::std::option::Option<extern "C" fn(func: GThreadFunc,
                                                           data: gpointer,
                                                           stack_size: gulong,
                                                           joinable: gboolean,
                                                           bound: gboolean,
                                                           priority:
                                                               GThreadPriority,
                                                           thread: gpointer,
                                                           error:
                                                               *mut *mut GError)
                                                 -> ()>,
    pub thread_yield: ::std::option::Option<extern "C" fn() -> ()>,
    pub thread_join: ::std::option::Option<extern "C" fn(thread: gpointer)
                                               -> ()>,
    pub thread_exit: ::std::option::Option<extern "C" fn() -> ()>,
    pub thread_set_priority: ::std::option::Option<extern "C" fn(thread:
                                                                     gpointer,
                                                                 priority:
                                                                     GThreadPriority)
                                                       -> ()>,
    pub thread_self: ::std::option::Option<extern "C" fn(thread: gpointer)
                                               -> ()>,
    pub thread_equal: ::std::option::Option<extern "C" fn(thread1: gpointer,
                                                          thread2: gpointer)
                                                -> gboolean>,
}
impl ::std::clone::Clone for Struct__GThreadFunctions {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GThreadFunctions {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type u_char = __u_char;
pub type u_short = __u_short;
pub type u_int = __u_int;
pub type u_long = __u_long;
pub type quad_t = __quad_t;
pub type u_quad_t = __u_quad_t;
pub type fsid_t = __fsid_t;
pub type loff_t = __loff_t;
pub type ino_t = __ino_t;
pub type dev_t = __dev_t;
pub type gid_t = __gid_t;
pub type mode_t = __mode_t;
pub type nlink_t = __nlink_t;
pub type off_t = __off_t;
pub type id_t = __id_t;
pub type ssize_t = __ssize_t;
pub type daddr_t = __daddr_t;
pub type caddr_t = __caddr_t;
pub type key_t = __key_t;
pub type ulong = ::libc::c_ulong;
pub type ushort = ::libc::c_ushort;
pub type _uint = ::libc::c_uint;
pub type int8_t = ::libc::c_char;
pub type int16_t = ::libc::c_short;
pub type int32_t = ::libc::c_int;
pub type int64_t = ::libc::c_long;
pub type u_int8_t = ::libc::c_uchar;
pub type u_int16_t = ::libc::c_ushort;
pub type u_int32_t = ::libc::c_uint;
pub type u_int64_t = ::libc::c_ulong;
pub type register_t = ::libc::c_long;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_timeval {
    pub tv_sec: __time_t,
    pub tv_usec: __suseconds_t,
}
impl ::std::clone::Clone for Struct_timeval {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_timeval {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type suseconds_t = __suseconds_t;
pub type __fd_mask = ::libc::c_long;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed94 {
    pub __fds_bits: [__fd_mask; 16usize],
}
impl ::std::clone::Clone for Struct_Unnamed94 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed94 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type fd_set = Struct_Unnamed94;
pub type fd_mask = __fd_mask;
pub type blksize_t = __blksize_t;
pub type blkcnt_t = __blkcnt_t;
pub type fsblkcnt_t = __fsblkcnt_t;
pub type fsfilcnt_t = __fsfilcnt_t;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_sched_param {
    pub __sched_priority: ::libc::c_int,
}
impl ::std::clone::Clone for Struct_sched_param {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_sched_param {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct___sched_param {
    pub __sched_priority: ::libc::c_int,
}
impl ::std::clone::Clone for Struct___sched_param {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct___sched_param {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type __cpu_mask = ::libc::c_ulong;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed95 {
    pub __bits: [__cpu_mask; 16usize],
}
impl ::std::clone::Clone for Struct_Unnamed95 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed95 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type cpu_set_t = Struct_Unnamed95;
pub type __jmp_buf = [::libc::c_long; 8usize];
pub type Enum_Unnamed96 = ::libc::c_uint;
pub const PTHREAD_CREATE_JOINABLE: ::libc::c_uint = 0;
pub const PTHREAD_CREATE_DETACHED: ::libc::c_uint = 1;
pub type Enum_Unnamed97 = ::libc::c_uint;
pub const PTHREAD_MUTEX_TIMED_NP: ::libc::c_uint = 0;
pub const PTHREAD_MUTEX_RECURSIVE_NP: ::libc::c_uint = 1;
pub const PTHREAD_MUTEX_ERRORCHECK_NP: ::libc::c_uint = 2;
pub const PTHREAD_MUTEX_ADAPTIVE_NP: ::libc::c_uint = 3;
pub const PTHREAD_MUTEX_NORMAL: ::libc::c_uint = 0;
pub const PTHREAD_MUTEX_RECURSIVE: ::libc::c_uint = 1;
pub const PTHREAD_MUTEX_ERRORCHECK: ::libc::c_uint = 2;
pub const PTHREAD_MUTEX_DEFAULT: ::libc::c_uint = 0;
pub type Enum_Unnamed98 = ::libc::c_uint;
pub const PTHREAD_MUTEX_STALLED: ::libc::c_uint = 0;
pub const PTHREAD_MUTEX_STALLED_NP: ::libc::c_uint = 0;
pub const PTHREAD_MUTEX_ROBUST: ::libc::c_uint = 1;
pub const PTHREAD_MUTEX_ROBUST_NP: ::libc::c_uint = 1;
pub type Enum_Unnamed99 = ::libc::c_uint;
pub const PTHREAD_PRIO_NONE: ::libc::c_uint = 0;
pub const PTHREAD_PRIO_INHERIT: ::libc::c_uint = 1;
pub const PTHREAD_PRIO_PROTECT: ::libc::c_uint = 2;
pub type Enum_Unnamed100 = ::libc::c_uint;
pub const PTHREAD_RWLOCK_PREFER_READER_NP: ::libc::c_uint = 0;
pub const PTHREAD_RWLOCK_PREFER_WRITER_NP: ::libc::c_uint = 1;
pub const PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP: ::libc::c_uint = 2;
pub const PTHREAD_RWLOCK_DEFAULT_NP: ::libc::c_uint = 0;
pub type Enum_Unnamed101 = ::libc::c_uint;
pub const PTHREAD_INHERIT_SCHED: ::libc::c_uint = 0;
pub const PTHREAD_EXPLICIT_SCHED: ::libc::c_uint = 1;
pub type Enum_Unnamed102 = ::libc::c_uint;
pub const PTHREAD_SCOPE_SYSTEM: ::libc::c_uint = 0;
pub const PTHREAD_SCOPE_PROCESS: ::libc::c_uint = 1;
pub type Enum_Unnamed103 = ::libc::c_uint;
pub const PTHREAD_PROCESS_PRIVATE: ::libc::c_uint = 0;
pub const PTHREAD_PROCESS_SHARED: ::libc::c_uint = 1;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__pthread_cleanup_buffer {
    pub __routine: ::std::option::Option<extern "C" fn(arg1:
                                                           *mut ::libc::c_void)
                                             -> ()>,
    pub __arg: *mut ::libc::c_void,
    pub __canceltype: ::libc::c_int,
    pub __prev: *mut Struct__pthread_cleanup_buffer,
}
impl ::std::clone::Clone for Struct__pthread_cleanup_buffer {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__pthread_cleanup_buffer {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type Enum_Unnamed104 = ::libc::c_uint;
pub const PTHREAD_CANCEL_ENABLE: ::libc::c_uint = 0;
pub const PTHREAD_CANCEL_DISABLE: ::libc::c_uint = 1;
pub type Enum_Unnamed105 = ::libc::c_uint;
pub const PTHREAD_CANCEL_DEFERRED: ::libc::c_uint = 0;
pub const PTHREAD_CANCEL_ASYNCHRONOUS: ::libc::c_uint = 1;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed106 {
    pub __cancel_jmp_buf: [Struct_Unnamed107; 1usize],
    pub __pad: [*mut ::libc::c_void; 4usize],
}
impl ::std::clone::Clone for Struct_Unnamed106 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed106 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed107 {
    pub __cancel_jmp_buf: __jmp_buf,
    pub __mask_was_saved: ::libc::c_int,
}
impl ::std::clone::Clone for Struct_Unnamed107 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed107 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type __pthread_unwind_buf_t = Struct_Unnamed106;
#[repr(C)]
#[derive(Copy)]
pub struct Struct___pthread_cleanup_frame {
    pub __cancel_routine: ::std::option::Option<extern "C" fn(arg1:
                                                                  *mut ::libc::c_void)
                                                    -> ()>,
    pub __cancel_arg: *mut ::libc::c_void,
    pub __do_it: ::libc::c_int,
    pub __cancel_type: ::libc::c_int,
}
impl ::std::clone::Clone for Struct___pthread_cleanup_frame {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct___pthread_cleanup_frame {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed108 {
    pub mutex: *mut GMutex,
    pub unused: pthread_mutex_t,
}
impl ::std::clone::Clone for Struct_Unnamed108 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed108 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type GStaticMutex = Struct_Unnamed108;
pub type GStaticRecMutex = Struct__GStaticRecMutex;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GStaticRecMutex {
    pub mutex: GStaticMutex,
    pub depth: guint,
    pub unused: Union_Unnamed109,
}
impl ::std::clone::Clone for Struct__GStaticRecMutex {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GStaticRecMutex {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed109 {
    pub _bindgen_data_: [u64; 1usize],
}
impl Union_Unnamed109 {
    pub unsafe fn owner(&mut self) -> *mut pthread_t {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn dummy(&mut self) -> *mut gdouble {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed109 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed109 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type GStaticRWLock = Struct__GStaticRWLock;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GStaticRWLock {
    pub mutex: GStaticMutex,
    pub read_cond: *mut GCond,
    pub write_cond: *mut GCond,
    pub read_counter: guint,
    pub have_writer: gboolean,
    pub want_to_read: guint,
    pub want_to_write: guint,
}
impl ::std::clone::Clone for Struct__GStaticRWLock {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GStaticRWLock {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type GStaticPrivate = Struct__GStaticPrivate;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__GStaticPrivate {
    pub index: guint,
}
impl ::std::clone::Clone for Struct__GStaticPrivate {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__GStaticPrivate {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub enum Struct__LogPipe { }
pub type LogPipe = Struct__LogPipe;
pub enum Struct__LogMessage { }
pub type LogMessage = Struct__LogMessage;
pub enum Struct__GlobalConfig { }
pub type GlobalConfig = Struct__GlobalConfig;
pub enum Struct__Bookmark { }
pub type Bookmark = Struct__Bookmark;
pub enum Struct__AckTracker { }
pub type AckTracker = Struct__AckTracker;
pub enum Struct__AckRecord { }
pub type AckRecord = Struct__AckRecord;
pub enum Struct__CfgArgs { }
pub type CfgArgs = Struct__CfgArgs;
pub type FILE = Struct__IO_FILE;
pub type __FILE = Struct__IO_FILE;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed110 {
    pub __count: ::libc::c_int,
    pub __value: Union_Unnamed111,
}
impl ::std::clone::Clone for Struct_Unnamed110 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed110 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed111 {
    pub _bindgen_data_: [u32; 1usize],
}
impl Union_Unnamed111 {
    pub unsafe fn __wch(&mut self) -> *mut ::libc::c_uint {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __wchb(&mut self) -> *mut [::libc::c_char; 4usize] {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed111 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed111 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type __mbstate_t = Struct_Unnamed110;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed112 {
    pub __pos: __off_t,
    pub __state: __mbstate_t,
}
impl ::std::clone::Clone for Struct_Unnamed112 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed112 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type _G_fpos_t = Struct_Unnamed112;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed113 {
    pub __pos: __off64_t,
    pub __state: __mbstate_t,
}
impl ::std::clone::Clone for Struct_Unnamed113 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed113 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type _G_fpos64_t = Struct_Unnamed113;
pub enum Struct__IO_jump_t { }
pub type _IO_lock_t = ::libc::c_void;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__IO_marker {
    pub _next: *mut Struct__IO_marker,
    pub _sbuf: *mut Struct__IO_FILE,
    pub _pos: ::libc::c_int,
}
impl ::std::clone::Clone for Struct__IO_marker {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__IO_marker {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type Enum___codecvt_result = ::libc::c_uint;
pub const __codecvt_ok: ::libc::c_uint = 0;
pub const __codecvt_partial: ::libc::c_uint = 1;
pub const __codecvt_error: ::libc::c_uint = 2;
pub const __codecvt_noconv: ::libc::c_uint = 3;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__IO_FILE {
    pub _flags: ::libc::c_int,
    pub _IO_read_ptr: *mut ::libc::c_char,
    pub _IO_read_end: *mut ::libc::c_char,
    pub _IO_read_base: *mut ::libc::c_char,
    pub _IO_write_base: *mut ::libc::c_char,
    pub _IO_write_ptr: *mut ::libc::c_char,
    pub _IO_write_end: *mut ::libc::c_char,
    pub _IO_buf_base: *mut ::libc::c_char,
    pub _IO_buf_end: *mut ::libc::c_char,
    pub _IO_save_base: *mut ::libc::c_char,
    pub _IO_backup_base: *mut ::libc::c_char,
    pub _IO_save_end: *mut ::libc::c_char,
    pub _markers: *mut Struct__IO_marker,
    pub _chain: *mut Struct__IO_FILE,
    pub _fileno: ::libc::c_int,
    pub _flags2: ::libc::c_int,
    pub _old_offset: __off_t,
    pub _cur_column: ::libc::c_ushort,
    pub _vtable_offset: ::libc::c_char,
    pub _shortbuf: [::libc::c_char; 1usize],
    pub _lock: *mut _IO_lock_t,
    pub _offset: __off64_t,
    pub __pad1: *mut ::libc::c_void,
    pub __pad2: *mut ::libc::c_void,
    pub __pad3: *mut ::libc::c_void,
    pub __pad4: *mut ::libc::c_void,
    pub __pad5: size_t,
    pub _mode: ::libc::c_int,
    pub _unused2: [::libc::c_char; 20usize],
}
impl ::std::clone::Clone for Struct__IO_FILE {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__IO_FILE {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type _IO_FILE = Struct__IO_FILE;
pub enum Struct__IO_FILE_plus { }
pub type __io_read_fn =
    extern "C" fn(__cookie: *mut ::libc::c_void, __buf: *mut ::libc::c_char,
                  __nbytes: size_t) -> __ssize_t;
pub type __io_write_fn =
    extern "C" fn(__cookie: *mut ::libc::c_void, __buf: *const ::libc::c_char,
                  __n: size_t) -> __ssize_t;
pub type __io_seek_fn =
    extern "C" fn(__cookie: *mut ::libc::c_void, __pos: *mut __off64_t,
                  __w: ::libc::c_int) -> ::libc::c_int;
pub type __io_close_fn =
    extern "C" fn(__cookie: *mut ::libc::c_void) -> ::libc::c_int;
pub type fpos_t = _G_fpos_t;
#[repr(C)]
#[derive(Copy)]
pub struct Struct___jmp_buf_tag {
    pub __jmpbuf: __jmp_buf,
    pub __mask_was_saved: ::libc::c_int,
    pub __saved_mask: __sigset_t,
}
impl ::std::clone::Clone for Struct___jmp_buf_tag {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct___jmp_buf_tag {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type jmp_buf = [Struct___jmp_buf_tag; 1usize];
pub type sigjmp_buf = [Struct___jmp_buf_tag; 1usize];
pub type CfgIncludeLevel = Struct__CfgIncludeLevel;
pub enum Struct__CfgTokenBlock { }
pub type CfgTokenBlock = Struct__CfgTokenBlock;
pub enum Struct__CfgBlockGenerator { }
pub type CfgBlockGenerator = Struct__CfgBlockGenerator;
pub enum Struct__CfgBlock { }
pub type CfgBlock = Struct__CfgBlock;
pub type CfgLexer = Struct__CfgLexer;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_YYLTYPE {
    pub first_line: ::libc::c_int,
    pub first_column: ::libc::c_int,
    pub last_line: ::libc::c_int,
    pub last_column: ::libc::c_int,
    pub level: *mut CfgIncludeLevel,
}
impl ::std::clone::Clone for Struct_YYLTYPE {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_YYLTYPE {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type YYLTYPE = Struct_YYLTYPE;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_YYSTYPE {
    pub _type: ::libc::c_int,
    pub _bindgen_data_1_: [u64; 1usize],
}
impl Struct_YYSTYPE {
    pub unsafe fn token(&mut self) -> *mut gint {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_1_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn num(&mut self) -> *mut gint64 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_1_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn fnum(&mut self) -> *mut ::libc::c_double {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_1_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn cptr(&mut self) -> *mut *mut ::libc::c_char {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_1_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn ptr(&mut self) -> *mut *mut ::libc::c_void {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_1_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn node(&mut self) -> *mut gpointer {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_1_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Struct_YYSTYPE {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_YYSTYPE {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type YYSTYPE = Struct_YYSTYPE;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__CfgLexerKeyword {
    pub kw_name: *mut gchar,
    pub kw_token: gint,
    pub kw_req_version: gint,
    pub kw_status: gint,
    pub kw_explain: *mut gchar,
}
impl ::std::clone::Clone for Struct__CfgLexerKeyword {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__CfgLexerKeyword {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type CfgLexerKeyword = Struct__CfgLexerKeyword;
pub type CfgBlockGeneratorFunc =
    ::std::option::Option<extern "C" fn(lexer: *mut CfgLexer, _type: gint,
                                        name: *const gchar,
                                        args: *mut CfgArgs,
                                        user_data: gpointer) -> gboolean>;
pub enum Struct_yy_buffer_state { }
#[repr(C)]
#[derive(Copy)]
pub struct Struct__CfgIncludeLevel {
    pub include_type: Enum_Unnamed114,
    pub name: *mut gchar,
    pub _bindgen_data_1_: [u64; 2usize],
    pub lloc: YYLTYPE,
    pub yybuf: *mut Struct_yy_buffer_state,
}
impl Struct__CfgIncludeLevel {
    pub unsafe fn file(&mut self) -> *mut Struct_Unnamed115 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_1_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn buffer(&mut self) -> *mut Struct_Unnamed116 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_1_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Struct__CfgIncludeLevel {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__CfgIncludeLevel {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed115 {
    pub files: *mut GSList,
    pub include_file: *mut FILE,
}
impl ::std::clone::Clone for Struct_Unnamed115 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed115 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed116 {
    pub content: *mut gchar,
    pub content_length: gsize,
}
impl ::std::clone::Clone for Struct_Unnamed116 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed116 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__CfgLexer {
    pub state: gpointer,
    pub fatal_error: jmp_buf,
    pub include_stack: [CfgIncludeLevel; 256usize],
    pub context_stack: *mut GList,
    pub include_depth: gint,
    pub block_boundary: [gchar; 2usize],
    pub brace_count: gint,
    pub tokenize_eol: gint,
    pub token_blocks: *mut GList,
    pub generators: *mut GList,
    pub string_buffer: *mut GString,
    pub preprocess_output: *mut GString,
    pub preprocess_suppress_tokens: gint,
    pub token_pretext: *mut GString,
    pub token_text: *mut GString,
    pub globals: *mut CfgArgs,
    pub _bindgen_bitfield_1_: gboolean,
    pub _bindgen_bitfield_2_: gboolean,
}
impl ::std::clone::Clone for Struct__CfgLexer {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__CfgLexer {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type Enum_CfgLexerError = ::libc::c_uint;
pub const CFG_LEXER_MISSING_BACKTICK_PAIR: ::libc::c_uint = 0;
pub const CFG_LEXER_CANNOT_REPRESENT_APOSTROPHES_IN_QSTRINGS: ::libc::c_uint =
    1;
pub const CFG_LEXER_BACKTICKS_CANT_BE_SUBSTITUTED_AFTER_BACKSLASH:
          ::libc::c_uint =
    2;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__CfgParser {
    pub debug_flag: *mut gint,
    pub context: gint,
    pub name: *const gchar,
    pub keywords: *mut CfgLexerKeyword,
    pub parse: ::std::option::Option<extern "C" fn(lexer: *mut CfgLexer,
                                                   instance: *mut gpointer,
                                                   arg: gpointer) -> gint>,
    pub cleanup: ::std::option::Option<extern "C" fn(instance: gpointer)
                                           -> ()>,
}
impl ::std::clone::Clone for Struct__CfgParser {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__CfgParser {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type CfgParser = Struct__CfgParser;
pub type Enum_Unnamed117 = ::libc::c_uint;
pub const CFH_SET: ::libc::c_uint = 0;
pub const CFH_CLEAR: ::libc::c_uint = 1;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__CfgFlagHandler {
    pub name: *const gchar,
    pub op: gint,
    pub ofs: gint,
    pub param: guint32,
    pub mask: guint32,
}
impl ::std::clone::Clone for Struct__CfgFlagHandler {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__CfgFlagHandler {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type CfgFlagHandler = Struct__CfgFlagHandler;
pub type Plugin = Struct__Plugin;
pub type ModuleInfo = Struct__ModuleInfo;
#[repr(C)]
#[derive(Copy)]
pub struct Struct__Plugin {
    pub _type: gint,
    pub name: *const gchar,
    pub parser: *mut CfgParser,
    pub setup_context: ::std::option::Option<extern "C" fn(_self: *mut Plugin,
                                                           cfg:
                                                               *mut GlobalConfig,
                                                           plugin_type: gint,
                                                           plugin_name:
                                                               *const gchar)
                                                 -> ()>,
    pub construct: ::std::option::Option<extern "C" fn(_self: *mut Plugin,
                                                       cfg: *mut GlobalConfig,
                                                       plugin_type: gint,
                                                       plugin_name:
                                                           *const gchar)
                                             -> gpointer>,
    pub free_fn: ::std::option::Option<extern "C" fn(s: *mut Plugin) -> ()>,
}
impl ::std::clone::Clone for Struct__Plugin {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__Plugin {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__ModuleInfo {
    pub canonical_name: *const gchar,
    pub version: *const gchar,
    pub description: *const gchar,
    pub core_revision: *const gchar,
    pub plugins: *mut Plugin,
    pub plugins_len: gint,
    pub preference: gint,
}
impl ::std::clone::Clone for Struct__ModuleInfo {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct__ModuleInfo {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[link(name = "syslog-ng")]
extern "C" {
    pub static mut __tzname: [*mut ::libc::c_char; 2usize];
    pub static mut __daylight: ::libc::c_int;
    pub static mut __timezone: ::libc::c_long;
    pub static mut tzname: [*mut ::libc::c_char; 2usize];
    pub static mut daylight: ::libc::c_int;
    pub static mut timezone: ::libc::c_long;
    pub static mut _sys_siglist: [*const ::libc::c_char; 65usize];
    pub static mut sys_siglist: [*const ::libc::c_char; 65usize];
    pub static mut g_mem_gc_friendly: gboolean;
    pub static mut glib_mem_profiler_table: *mut GMemVTable;
    pub static mut g_timeout_funcs: GSourceFuncs;
    pub static mut g_child_watch_funcs: GSourceFuncs;
    pub static mut g_idle_funcs: GSourceFuncs;
    pub static mut g_unix_signal_funcs: GSourceFuncs;
    pub static mut g_unix_fd_source_funcs: GSourceFuncs;
    pub static g_utf8_skip: *const gchar;
    pub static mut g_io_watch_funcs: GSourceFuncs;
    pub static g_ascii_table: *const guint16;
    pub static g_test_config_vars: *const GTestConfig;
    pub static glib_major_version: guint;
    pub static glib_minor_version: guint;
    pub static glib_micro_version: guint;
    pub static glib_interface_age: guint;
    pub static glib_binary_age: guint;
    pub static mut g_thread_functions_for_glib_use: GThreadFunctions;
    pub static mut g_thread_use_default_impl: gboolean;
    pub static mut g_thread_gettime:
               ::std::option::Option<extern "C" fn() -> guint64>;
    pub static mut g_threads_got_initialized: gboolean;
    pub static mut configuration: *mut GlobalConfig;
    pub static mut module_path: *const gchar;
    pub static mut java_module_path: *const gchar;
    pub static mut _IO_2_1_stdin_: Struct__IO_FILE_plus;
    pub static mut _IO_2_1_stdout_: Struct__IO_FILE_plus;
    pub static mut _IO_2_1_stderr_: Struct__IO_FILE_plus;
    pub static mut stdin: *mut Struct__IO_FILE;
    pub static mut stdout: *mut Struct__IO_FILE;
    pub static mut stderr: *mut Struct__IO_FILE;
    pub static mut sys_nerr: ::libc::c_int;
    pub static mut sys_errlist: *const *const ::libc::c_char;
    pub static mut cfg_parser_debug: ::libc::c_int;
    pub static mut main_parser: CfgParser;
}
#[link(name = "syslog-ng")]
extern "C" {
    pub fn clock() -> clock_t;
    pub fn time(__timer: *mut time_t) -> time_t;
    pub fn difftime(__time1: time_t, __time0: time_t) -> ::libc::c_double;
    pub fn mktime(__tp: *mut Struct_tm) -> time_t;
    pub fn strftime(__s: *mut ::libc::c_char, __maxsize: size_t,
                    __format: *const ::libc::c_char, __tp: *const Struct_tm)
     -> size_t;
    pub fn strftime_l(__s: *mut ::libc::c_char, __maxsize: size_t,
                      __format: *const ::libc::c_char, __tp: *const Struct_tm,
                      __loc: __locale_t) -> size_t;
    pub fn gmtime(__timer: *const time_t) -> *mut Struct_tm;
    pub fn localtime(__timer: *const time_t) -> *mut Struct_tm;
    pub fn gmtime_r(__timer: *const time_t, __tp: *mut Struct_tm)
     -> *mut Struct_tm;
    pub fn localtime_r(__timer: *const time_t, __tp: *mut Struct_tm)
     -> *mut Struct_tm;
    pub fn asctime(__tp: *const Struct_tm) -> *mut ::libc::c_char;
    pub fn ctime(__timer: *const time_t) -> *mut ::libc::c_char;
    pub fn asctime_r(__tp: *const Struct_tm, __buf: *mut ::libc::c_char)
     -> *mut ::libc::c_char;
    pub fn ctime_r(__timer: *const time_t, __buf: *mut ::libc::c_char)
     -> *mut ::libc::c_char;
    pub fn tzset() -> ();
    pub fn stime(__when: *const time_t) -> ::libc::c_int;
    pub fn timegm(__tp: *mut Struct_tm) -> time_t;
    pub fn timelocal(__tp: *mut Struct_tm) -> time_t;
    pub fn dysize(__year: ::libc::c_int) -> ::libc::c_int;
    pub fn nanosleep(__requested_time: *const Struct_timespec,
                     __remaining: *mut Struct_timespec) -> ::libc::c_int;
    pub fn clock_getres(__clock_id: clockid_t, __res: *mut Struct_timespec)
     -> ::libc::c_int;
    pub fn clock_gettime(__clock_id: clockid_t, __tp: *mut Struct_timespec)
     -> ::libc::c_int;
    pub fn clock_settime(__clock_id: clockid_t, __tp: *const Struct_timespec)
     -> ::libc::c_int;
    pub fn clock_nanosleep(__clock_id: clockid_t, __flags: ::libc::c_int,
                           __req: *const Struct_timespec,
                           __rem: *mut Struct_timespec) -> ::libc::c_int;
    pub fn clock_getcpuclockid(__pid: pid_t, __clock_id: *mut clockid_t)
     -> ::libc::c_int;
    pub fn timer_create(__clock_id: clockid_t, __evp: *mut Struct_sigevent,
                        __timerid: *mut timer_t) -> ::libc::c_int;
    pub fn timer_delete(__timerid: timer_t) -> ::libc::c_int;
    pub fn timer_settime(__timerid: timer_t, __flags: ::libc::c_int,
                         __value: *const Struct_itimerspec,
                         __ovalue: *mut Struct_itimerspec) -> ::libc::c_int;
    pub fn timer_gettime(__timerid: timer_t, __value: *mut Struct_itimerspec)
     -> ::libc::c_int;
    pub fn timer_getoverrun(__timerid: timer_t) -> ::libc::c_int;
    pub fn g_array_new(zero_terminated: gboolean, clear_: gboolean,
                       element_size: guint) -> *mut GArray;
    pub fn g_array_sized_new(zero_terminated: gboolean, clear_: gboolean,
                             element_size: guint, reserved_size: guint)
     -> *mut GArray;
    pub fn g_array_free(array: *mut GArray, free_segment: gboolean)
     -> *mut gchar;
    pub fn g_array_ref(array: *mut GArray) -> *mut GArray;
    pub fn g_array_unref(array: *mut GArray) -> ();
    pub fn g_array_get_element_size(array: *mut GArray) -> guint;
    pub fn g_array_append_vals(array: *mut GArray, data: gconstpointer,
                               len: guint) -> *mut GArray;
    pub fn g_array_prepend_vals(array: *mut GArray, data: gconstpointer,
                                len: guint) -> *mut GArray;
    pub fn g_array_insert_vals(array: *mut GArray, index_: guint,
                               data: gconstpointer, len: guint)
     -> *mut GArray;
    pub fn g_array_set_size(array: *mut GArray, length: guint) -> *mut GArray;
    pub fn g_array_remove_index(array: *mut GArray, index_: guint)
     -> *mut GArray;
    pub fn g_array_remove_index_fast(array: *mut GArray, index_: guint)
     -> *mut GArray;
    pub fn g_array_remove_range(array: *mut GArray, index_: guint,
                                length: guint) -> *mut GArray;
    pub fn g_array_sort(array: *mut GArray, compare_func: GCompareFunc) -> ();
    pub fn g_array_sort_with_data(array: *mut GArray,
                                  compare_func: GCompareDataFunc,
                                  user_data: gpointer) -> ();
    pub fn g_array_set_clear_func(array: *mut GArray,
                                  clear_func: GDestroyNotify) -> ();
    pub fn g_ptr_array_new() -> *mut GPtrArray;
    pub fn g_ptr_array_new_with_free_func(element_free_func: GDestroyNotify)
     -> *mut GPtrArray;
    pub fn g_ptr_array_sized_new(reserved_size: guint) -> *mut GPtrArray;
    pub fn g_ptr_array_new_full(reserved_size: guint,
                                element_free_func: GDestroyNotify)
     -> *mut GPtrArray;
    pub fn g_ptr_array_free(array: *mut GPtrArray, free_seg: gboolean)
     -> *mut gpointer;
    pub fn g_ptr_array_ref(array: *mut GPtrArray) -> *mut GPtrArray;
    pub fn g_ptr_array_unref(array: *mut GPtrArray) -> ();
    pub fn g_ptr_array_set_free_func(array: *mut GPtrArray,
                                     element_free_func: GDestroyNotify) -> ();
    pub fn g_ptr_array_set_size(array: *mut GPtrArray, length: gint) -> ();
    pub fn g_ptr_array_remove_index(array: *mut GPtrArray, index_: guint)
     -> gpointer;
    pub fn g_ptr_array_remove_index_fast(array: *mut GPtrArray, index_: guint)
     -> gpointer;
    pub fn g_ptr_array_remove(array: *mut GPtrArray, data: gpointer)
     -> gboolean;
    pub fn g_ptr_array_remove_fast(array: *mut GPtrArray, data: gpointer)
     -> gboolean;
    pub fn g_ptr_array_remove_range(array: *mut GPtrArray, index_: guint,
                                    length: guint) -> *mut GPtrArray;
    pub fn g_ptr_array_add(array: *mut GPtrArray, data: gpointer) -> ();
    pub fn g_ptr_array_insert(array: *mut GPtrArray, index_: gint,
                              data: gpointer) -> ();
    pub fn g_ptr_array_sort(array: *mut GPtrArray, compare_func: GCompareFunc)
     -> ();
    pub fn g_ptr_array_sort_with_data(array: *mut GPtrArray,
                                      compare_func: GCompareDataFunc,
                                      user_data: gpointer) -> ();
    pub fn g_ptr_array_foreach(array: *mut GPtrArray, func: GFunc,
                               user_data: gpointer) -> ();
    pub fn g_byte_array_new() -> *mut GByteArray;
    pub fn g_byte_array_new_take(data: *mut guint8, len: gsize)
     -> *mut GByteArray;
    pub fn g_byte_array_sized_new(reserved_size: guint) -> *mut GByteArray;
    pub fn g_byte_array_free(array: *mut GByteArray, free_segment: gboolean)
     -> *mut guint8;
    pub fn g_byte_array_free_to_bytes(array: *mut GByteArray) -> *mut GBytes;
    pub fn g_byte_array_ref(array: *mut GByteArray) -> *mut GByteArray;
    pub fn g_byte_array_unref(array: *mut GByteArray) -> ();
    pub fn g_byte_array_append(array: *mut GByteArray, data: *const guint8,
                               len: guint) -> *mut GByteArray;
    pub fn g_byte_array_prepend(array: *mut GByteArray, data: *const guint8,
                                len: guint) -> *mut GByteArray;
    pub fn g_byte_array_set_size(array: *mut GByteArray, length: guint)
     -> *mut GByteArray;
    pub fn g_byte_array_remove_index(array: *mut GByteArray, index_: guint)
     -> *mut GByteArray;
    pub fn g_byte_array_remove_index_fast(array: *mut GByteArray,
                                          index_: guint) -> *mut GByteArray;
    pub fn g_byte_array_remove_range(array: *mut GByteArray, index_: guint,
                                     length: guint) -> *mut GByteArray;
    pub fn g_byte_array_sort(array: *mut GByteArray,
                             compare_func: GCompareFunc) -> ();
    pub fn g_byte_array_sort_with_data(array: *mut GByteArray,
                                       compare_func: GCompareDataFunc,
                                       user_data: gpointer) -> ();
    pub fn g_atomic_int_get(atomic: *const gint) -> gint;
    pub fn g_atomic_int_set(atomic: *mut gint, newval: gint) -> ();
    pub fn g_atomic_int_inc(atomic: *mut gint) -> ();
    pub fn g_atomic_int_dec_and_test(atomic: *mut gint) -> gboolean;
    pub fn g_atomic_int_compare_and_exchange(atomic: *mut gint, oldval: gint,
                                             newval: gint) -> gboolean;
    pub fn g_atomic_int_add(atomic: *mut gint, val: gint) -> gint;
    pub fn g_atomic_int_and(atomic: *mut guint, val: guint) -> guint;
    pub fn g_atomic_int_or(atomic: *mut guint, val: guint) -> guint;
    pub fn g_atomic_int_xor(atomic: *mut guint, val: guint) -> guint;
    pub fn g_atomic_pointer_get(atomic: *const ::libc::c_void) -> gpointer;
    pub fn g_atomic_pointer_set(atomic: *mut ::libc::c_void, newval: gpointer)
     -> ();
    pub fn g_atomic_pointer_compare_and_exchange(atomic: *mut ::libc::c_void,
                                                 oldval: gpointer,
                                                 newval: gpointer)
     -> gboolean;
    pub fn g_atomic_pointer_add(atomic: *mut ::libc::c_void, val: gssize)
     -> gssize;
    pub fn g_atomic_pointer_and(atomic: *mut ::libc::c_void, val: gsize)
     -> gsize;
    pub fn g_atomic_pointer_or(atomic: *mut ::libc::c_void, val: gsize)
     -> gsize;
    pub fn g_atomic_pointer_xor(atomic: *mut ::libc::c_void, val: gsize)
     -> gsize;
    pub fn g_atomic_int_exchange_and_add(atomic: *mut gint, val: gint)
     -> gint;
    pub fn g_quark_try_string(string: *const gchar) -> GQuark;
    pub fn g_quark_from_static_string(string: *const gchar) -> GQuark;
    pub fn g_quark_from_string(string: *const gchar) -> GQuark;
    pub fn g_quark_to_string(quark: GQuark) -> *const gchar;
    pub fn g_intern_string(string: *const gchar) -> *const gchar;
    pub fn g_intern_static_string(string: *const gchar) -> *const gchar;
    pub fn g_error_new(domain: GQuark, code: gint, format: *const gchar, ...)
     -> *mut GError;
    pub fn g_error_new_literal(domain: GQuark, code: gint,
                               message: *const gchar) -> *mut GError;
    pub fn g_error_new_valist(domain: GQuark, code: gint,
                              format: *const gchar, args: va_list)
     -> *mut GError;
    pub fn g_error_free(error: *mut GError) -> ();
    pub fn g_error_copy(error: *const GError) -> *mut GError;
    pub fn g_error_matches(error: *const GError, domain: GQuark, code: gint)
     -> gboolean;
    pub fn g_set_error(err: *mut *mut GError, domain: GQuark, code: gint,
                       format: *const gchar, ...) -> ();
    pub fn g_set_error_literal(err: *mut *mut GError, domain: GQuark,
                               code: gint, message: *const gchar) -> ();
    pub fn g_propagate_error(dest: *mut *mut GError, src: *mut GError) -> ();
    pub fn g_clear_error(err: *mut *mut GError) -> ();
    pub fn g_prefix_error(err: *mut *mut GError, format: *const gchar, ...)
     -> ();
    pub fn g_propagate_prefixed_error(dest: *mut *mut GError,
                                      src: *mut GError,
                                      format: *const gchar, ...) -> ();
    pub fn g_thread_error_quark() -> GQuark;
    pub fn g_thread_ref(thread: *mut GThread) -> *mut GThread;
    pub fn g_thread_unref(thread: *mut GThread) -> ();
    pub fn g_thread_new(name: *const gchar, func: GThreadFunc, data: gpointer)
     -> *mut GThread;
    pub fn g_thread_try_new(name: *const gchar, func: GThreadFunc,
                            data: gpointer, error: *mut *mut GError)
     -> *mut GThread;
    pub fn g_thread_self() -> *mut GThread;
    pub fn g_thread_exit(retval: gpointer) -> ();
    pub fn g_thread_join(thread: *mut GThread) -> gpointer;
    pub fn g_thread_yield() -> ();
    pub fn g_mutex_init(mutex: *mut GMutex) -> ();
    pub fn g_mutex_clear(mutex: *mut GMutex) -> ();
    pub fn g_mutex_lock(mutex: *mut GMutex) -> ();
    pub fn g_mutex_trylock(mutex: *mut GMutex) -> gboolean;
    pub fn g_mutex_unlock(mutex: *mut GMutex) -> ();
    pub fn g_rw_lock_init(rw_lock: *mut GRWLock) -> ();
    pub fn g_rw_lock_clear(rw_lock: *mut GRWLock) -> ();
    pub fn g_rw_lock_writer_lock(rw_lock: *mut GRWLock) -> ();
    pub fn g_rw_lock_writer_trylock(rw_lock: *mut GRWLock) -> gboolean;
    pub fn g_rw_lock_writer_unlock(rw_lock: *mut GRWLock) -> ();
    pub fn g_rw_lock_reader_lock(rw_lock: *mut GRWLock) -> ();
    pub fn g_rw_lock_reader_trylock(rw_lock: *mut GRWLock) -> gboolean;
    pub fn g_rw_lock_reader_unlock(rw_lock: *mut GRWLock) -> ();
    pub fn g_rec_mutex_init(rec_mutex: *mut GRecMutex) -> ();
    pub fn g_rec_mutex_clear(rec_mutex: *mut GRecMutex) -> ();
    pub fn g_rec_mutex_lock(rec_mutex: *mut GRecMutex) -> ();
    pub fn g_rec_mutex_trylock(rec_mutex: *mut GRecMutex) -> gboolean;
    pub fn g_rec_mutex_unlock(rec_mutex: *mut GRecMutex) -> ();
    pub fn g_cond_init(cond: *mut GCond) -> ();
    pub fn g_cond_clear(cond: *mut GCond) -> ();
    pub fn g_cond_wait(cond: *mut GCond, mutex: *mut GMutex) -> ();
    pub fn g_cond_signal(cond: *mut GCond) -> ();
    pub fn g_cond_broadcast(cond: *mut GCond) -> ();
    pub fn g_cond_wait_until(cond: *mut GCond, mutex: *mut GMutex,
                             end_time: gint64) -> gboolean;
    pub fn g_private_get(key: *mut GPrivate) -> gpointer;
    pub fn g_private_set(key: *mut GPrivate, value: gpointer) -> ();
    pub fn g_private_replace(key: *mut GPrivate, value: gpointer) -> ();
    pub fn g_once_impl(once: *mut GOnce, func: GThreadFunc, arg: gpointer)
     -> gpointer;
    pub fn g_once_init_enter(location: *mut ::libc::c_void) -> gboolean;
    pub fn g_once_init_leave(location: *mut ::libc::c_void, result: gsize)
     -> ();
    pub fn g_get_num_processors() -> guint;
    pub fn g_async_queue_new() -> *mut GAsyncQueue;
    pub fn g_async_queue_new_full(item_free_func: GDestroyNotify)
     -> *mut GAsyncQueue;
    pub fn g_async_queue_lock(queue: *mut GAsyncQueue) -> ();
    pub fn g_async_queue_unlock(queue: *mut GAsyncQueue) -> ();
    pub fn g_async_queue_ref(queue: *mut GAsyncQueue) -> *mut GAsyncQueue;
    pub fn g_async_queue_unref(queue: *mut GAsyncQueue) -> ();
    pub fn g_async_queue_ref_unlocked(queue: *mut GAsyncQueue) -> ();
    pub fn g_async_queue_unref_and_unlock(queue: *mut GAsyncQueue) -> ();
    pub fn g_async_queue_push(queue: *mut GAsyncQueue, data: gpointer) -> ();
    pub fn g_async_queue_push_unlocked(queue: *mut GAsyncQueue,
                                       data: gpointer) -> ();
    pub fn g_async_queue_push_sorted(queue: *mut GAsyncQueue, data: gpointer,
                                     func: GCompareDataFunc,
                                     user_data: gpointer) -> ();
    pub fn g_async_queue_push_sorted_unlocked(queue: *mut GAsyncQueue,
                                              data: gpointer,
                                              func: GCompareDataFunc,
                                              user_data: gpointer) -> ();
    pub fn g_async_queue_pop(queue: *mut GAsyncQueue) -> gpointer;
    pub fn g_async_queue_pop_unlocked(queue: *mut GAsyncQueue) -> gpointer;
    pub fn g_async_queue_try_pop(queue: *mut GAsyncQueue) -> gpointer;
    pub fn g_async_queue_try_pop_unlocked(queue: *mut GAsyncQueue)
     -> gpointer;
    pub fn g_async_queue_timeout_pop(queue: *mut GAsyncQueue,
                                     timeout: guint64) -> gpointer;
    pub fn g_async_queue_timeout_pop_unlocked(queue: *mut GAsyncQueue,
                                              timeout: guint64) -> gpointer;
    pub fn g_async_queue_length(queue: *mut GAsyncQueue) -> gint;
    pub fn g_async_queue_length_unlocked(queue: *mut GAsyncQueue) -> gint;
    pub fn g_async_queue_sort(queue: *mut GAsyncQueue, func: GCompareDataFunc,
                              user_data: gpointer) -> ();
    pub fn g_async_queue_sort_unlocked(queue: *mut GAsyncQueue,
                                       func: GCompareDataFunc,
                                       user_data: gpointer) -> ();
    pub fn g_async_queue_timed_pop(queue: *mut GAsyncQueue,
                                   end_time: *mut GTimeVal) -> gpointer;
    pub fn g_async_queue_timed_pop_unlocked(queue: *mut GAsyncQueue,
                                            end_time: *mut GTimeVal)
     -> gpointer;
    pub fn __sigismember(arg1: *const __sigset_t, arg2: ::libc::c_int)
     -> ::libc::c_int;
    pub fn __sigaddset(arg1: *mut __sigset_t, arg2: ::libc::c_int)
     -> ::libc::c_int;
    pub fn __sigdelset(arg1: *mut __sigset_t, arg2: ::libc::c_int)
     -> ::libc::c_int;
    pub fn __sysv_signal(__sig: ::libc::c_int, __handler: __sighandler_t)
     -> __sighandler_t;
    pub fn signal(__sig: ::libc::c_int, __handler: __sighandler_t)
     -> __sighandler_t;
    pub fn kill(__pid: __pid_t, __sig: ::libc::c_int) -> ::libc::c_int;
    pub fn killpg(__pgrp: __pid_t, __sig: ::libc::c_int) -> ::libc::c_int;
    pub fn raise(__sig: ::libc::c_int) -> ::libc::c_int;
    pub fn ssignal(__sig: ::libc::c_int, __handler: __sighandler_t)
     -> __sighandler_t;
    pub fn gsignal(__sig: ::libc::c_int) -> ::libc::c_int;
    pub fn psignal(__sig: ::libc::c_int, __s: *const ::libc::c_char) -> ();
    pub fn psiginfo(__pinfo: *const siginfo_t, __s: *const ::libc::c_char)
     -> ();
    pub fn __sigpause(__sig_or_mask: ::libc::c_int, __is_sig: ::libc::c_int)
     -> ::libc::c_int;
    pub fn sigblock(__mask: ::libc::c_int) -> ::libc::c_int;
    pub fn sigsetmask(__mask: ::libc::c_int) -> ::libc::c_int;
    pub fn siggetmask() -> ::libc::c_int;
    pub fn sigemptyset(__set: *mut sigset_t) -> ::libc::c_int;
    pub fn sigfillset(__set: *mut sigset_t) -> ::libc::c_int;
    pub fn sigaddset(__set: *mut sigset_t, __signo: ::libc::c_int)
     -> ::libc::c_int;
    pub fn sigdelset(__set: *mut sigset_t, __signo: ::libc::c_int)
     -> ::libc::c_int;
    pub fn sigismember(__set: *const sigset_t, __signo: ::libc::c_int)
     -> ::libc::c_int;
    pub fn sigprocmask(__how: ::libc::c_int, __set: *const sigset_t,
                       __oset: *mut sigset_t) -> ::libc::c_int;
    pub fn sigsuspend(__set: *const sigset_t) -> ::libc::c_int;
    pub fn sigaction(__sig: ::libc::c_int, __act: *const Struct_sigaction,
                     __oact: *mut Struct_sigaction) -> ::libc::c_int;
    pub fn sigpending(__set: *mut sigset_t) -> ::libc::c_int;
    pub fn sigwait(__set: *const sigset_t, __sig: *mut ::libc::c_int)
     -> ::libc::c_int;
    pub fn sigwaitinfo(__set: *const sigset_t, __info: *mut siginfo_t)
     -> ::libc::c_int;
    pub fn sigtimedwait(__set: *const sigset_t, __info: *mut siginfo_t,
                        __timeout: *const Struct_timespec) -> ::libc::c_int;
    pub fn sigqueue(__pid: __pid_t, __sig: ::libc::c_int, __val: Union_sigval)
     -> ::libc::c_int;
    pub fn sigvec(__sig: ::libc::c_int, __vec: *const Struct_sigvec,
                  __ovec: *mut Struct_sigvec) -> ::libc::c_int;
    pub fn sigreturn(__scp: *mut Struct_sigcontext) -> ::libc::c_int;
    pub fn siginterrupt(__sig: ::libc::c_int, __interrupt: ::libc::c_int)
     -> ::libc::c_int;
    pub fn sigstack(__ss: *mut Struct_sigstack, __oss: *mut Struct_sigstack)
     -> ::libc::c_int;
    pub fn sigaltstack(__ss: *const Struct_sigaltstack,
                       __oss: *mut Struct_sigaltstack) -> ::libc::c_int;
    pub fn pthread_sigmask(__how: ::libc::c_int, __newmask: *const __sigset_t,
                           __oldmask: *mut __sigset_t) -> ::libc::c_int;
    pub fn pthread_kill(__threadid: pthread_t, __signo: ::libc::c_int)
     -> ::libc::c_int;
    pub fn __libc_current_sigrtmin() -> ::libc::c_int;
    pub fn __libc_current_sigrtmax() -> ::libc::c_int;
    pub fn g_on_error_query(prg_name: *const gchar) -> ();
    pub fn g_on_error_stack_trace(prg_name: *const gchar) -> ();
    pub fn g_base64_encode_step(_in: *const guchar, len: gsize,
                                break_lines: gboolean, out: *mut gchar,
                                state: *mut gint, save: *mut gint) -> gsize;
    pub fn g_base64_encode_close(break_lines: gboolean, out: *mut gchar,
                                 state: *mut gint, save: *mut gint) -> gsize;
    pub fn g_base64_encode(data: *const guchar, len: gsize) -> *mut gchar;
    pub fn g_base64_decode_step(_in: *const gchar, len: gsize,
                                out: *mut guchar, state: *mut gint,
                                save: *mut guint) -> gsize;
    pub fn g_base64_decode(text: *const gchar, out_len: *mut gsize)
     -> *mut guchar;
    pub fn g_base64_decode_inplace(text: *mut gchar, out_len: *mut gsize)
     -> *mut guchar;
    pub fn g_bit_lock(address: *mut gint, lock_bit: gint) -> ();
    pub fn g_bit_trylock(address: *mut gint, lock_bit: gint) -> gboolean;
    pub fn g_bit_unlock(address: *mut gint, lock_bit: gint) -> ();
    pub fn g_pointer_bit_lock(address: *mut ::libc::c_void, lock_bit: gint)
     -> ();
    pub fn g_pointer_bit_trylock(address: *mut ::libc::c_void, lock_bit: gint)
     -> gboolean;
    pub fn g_pointer_bit_unlock(address: *mut ::libc::c_void, lock_bit: gint)
     -> ();
    pub fn g_bookmark_file_error_quark() -> GQuark;
    pub fn g_bookmark_file_new() -> *mut GBookmarkFile;
    pub fn g_bookmark_file_free(bookmark: *mut GBookmarkFile) -> ();
    pub fn g_bookmark_file_load_from_file(bookmark: *mut GBookmarkFile,
                                          filename: *const gchar,
                                          error: *mut *mut GError)
     -> gboolean;
    pub fn g_bookmark_file_load_from_data(bookmark: *mut GBookmarkFile,
                                          data: *const gchar, length: gsize,
                                          error: *mut *mut GError)
     -> gboolean;
    pub fn g_bookmark_file_load_from_data_dirs(bookmark: *mut GBookmarkFile,
                                               file: *const gchar,
                                               full_path: *mut *mut gchar,
                                               error: *mut *mut GError)
     -> gboolean;
    pub fn g_bookmark_file_to_data(bookmark: *mut GBookmarkFile,
                                   length: *mut gsize,
                                   error: *mut *mut GError) -> *mut gchar;
    pub fn g_bookmark_file_to_file(bookmark: *mut GBookmarkFile,
                                   filename: *const gchar,
                                   error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_set_title(bookmark: *mut GBookmarkFile,
                                     uri: *const gchar, title: *const gchar)
     -> ();
    pub fn g_bookmark_file_get_title(bookmark: *mut GBookmarkFile,
                                     uri: *const gchar,
                                     error: *mut *mut GError) -> *mut gchar;
    pub fn g_bookmark_file_set_description(bookmark: *mut GBookmarkFile,
                                           uri: *const gchar,
                                           description: *const gchar) -> ();
    pub fn g_bookmark_file_get_description(bookmark: *mut GBookmarkFile,
                                           uri: *const gchar,
                                           error: *mut *mut GError)
     -> *mut gchar;
    pub fn g_bookmark_file_set_mime_type(bookmark: *mut GBookmarkFile,
                                         uri: *const gchar,
                                         mime_type: *const gchar) -> ();
    pub fn g_bookmark_file_get_mime_type(bookmark: *mut GBookmarkFile,
                                         uri: *const gchar,
                                         error: *mut *mut GError)
     -> *mut gchar;
    pub fn g_bookmark_file_set_groups(bookmark: *mut GBookmarkFile,
                                      uri: *const gchar,
                                      groups: *mut *const gchar,
                                      length: gsize) -> ();
    pub fn g_bookmark_file_add_group(bookmark: *mut GBookmarkFile,
                                     uri: *const gchar, group: *const gchar)
     -> ();
    pub fn g_bookmark_file_has_group(bookmark: *mut GBookmarkFile,
                                     uri: *const gchar, group: *const gchar,
                                     error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_get_groups(bookmark: *mut GBookmarkFile,
                                      uri: *const gchar, length: *mut gsize,
                                      error: *mut *mut GError)
     -> *mut *mut gchar;
    pub fn g_bookmark_file_add_application(bookmark: *mut GBookmarkFile,
                                           uri: *const gchar,
                                           name: *const gchar,
                                           exec: *const gchar) -> ();
    pub fn g_bookmark_file_has_application(bookmark: *mut GBookmarkFile,
                                           uri: *const gchar,
                                           name: *const gchar,
                                           error: *mut *mut GError)
     -> gboolean;
    pub fn g_bookmark_file_get_applications(bookmark: *mut GBookmarkFile,
                                            uri: *const gchar,
                                            length: *mut gsize,
                                            error: *mut *mut GError)
     -> *mut *mut gchar;
    pub fn g_bookmark_file_set_app_info(bookmark: *mut GBookmarkFile,
                                        uri: *const gchar, name: *const gchar,
                                        exec: *const gchar, count: gint,
                                        stamp: time_t,
                                        error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_get_app_info(bookmark: *mut GBookmarkFile,
                                        uri: *const gchar, name: *const gchar,
                                        exec: *mut *mut gchar,
                                        count: *mut guint, stamp: *mut time_t,
                                        error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_set_is_private(bookmark: *mut GBookmarkFile,
                                          uri: *const gchar,
                                          is_private: gboolean) -> ();
    pub fn g_bookmark_file_get_is_private(bookmark: *mut GBookmarkFile,
                                          uri: *const gchar,
                                          error: *mut *mut GError)
     -> gboolean;
    pub fn g_bookmark_file_set_icon(bookmark: *mut GBookmarkFile,
                                    uri: *const gchar, href: *const gchar,
                                    mime_type: *const gchar) -> ();
    pub fn g_bookmark_file_get_icon(bookmark: *mut GBookmarkFile,
                                    uri: *const gchar, href: *mut *mut gchar,
                                    mime_type: *mut *mut gchar,
                                    error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_set_added(bookmark: *mut GBookmarkFile,
                                     uri: *const gchar, added: time_t) -> ();
    pub fn g_bookmark_file_get_added(bookmark: *mut GBookmarkFile,
                                     uri: *const gchar,
                                     error: *mut *mut GError) -> time_t;
    pub fn g_bookmark_file_set_modified(bookmark: *mut GBookmarkFile,
                                        uri: *const gchar, modified: time_t)
     -> ();
    pub fn g_bookmark_file_get_modified(bookmark: *mut GBookmarkFile,
                                        uri: *const gchar,
                                        error: *mut *mut GError) -> time_t;
    pub fn g_bookmark_file_set_visited(bookmark: *mut GBookmarkFile,
                                       uri: *const gchar, visited: time_t)
     -> ();
    pub fn g_bookmark_file_get_visited(bookmark: *mut GBookmarkFile,
                                       uri: *const gchar,
                                       error: *mut *mut GError) -> time_t;
    pub fn g_bookmark_file_has_item(bookmark: *mut GBookmarkFile,
                                    uri: *const gchar) -> gboolean;
    pub fn g_bookmark_file_get_size(bookmark: *mut GBookmarkFile) -> gint;
    pub fn g_bookmark_file_get_uris(bookmark: *mut GBookmarkFile,
                                    length: *mut gsize) -> *mut *mut gchar;
    pub fn g_bookmark_file_remove_group(bookmark: *mut GBookmarkFile,
                                        uri: *const gchar,
                                        group: *const gchar,
                                        error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_remove_application(bookmark: *mut GBookmarkFile,
                                              uri: *const gchar,
                                              name: *const gchar,
                                              error: *mut *mut GError)
     -> gboolean;
    pub fn g_bookmark_file_remove_item(bookmark: *mut GBookmarkFile,
                                       uri: *const gchar,
                                       error: *mut *mut GError) -> gboolean;
    pub fn g_bookmark_file_move_item(bookmark: *mut GBookmarkFile,
                                     old_uri: *const gchar,
                                     new_uri: *const gchar,
                                     error: *mut *mut GError) -> gboolean;
    pub fn g_bytes_new(data: gconstpointer, size: gsize) -> *mut GBytes;
    pub fn g_bytes_new_take(data: gpointer, size: gsize) -> *mut GBytes;
    pub fn g_bytes_new_static(data: gconstpointer, size: gsize)
     -> *mut GBytes;
    pub fn g_bytes_new_with_free_func(data: gconstpointer, size: gsize,
                                      free_func: GDestroyNotify,
                                      user_data: gpointer) -> *mut GBytes;
    pub fn g_bytes_new_from_bytes(bytes: *mut GBytes, offset: gsize,
                                  length: gsize) -> *mut GBytes;
    pub fn g_bytes_get_data(bytes: *mut GBytes, size: *mut gsize)
     -> gconstpointer;
    pub fn g_bytes_get_size(bytes: *mut GBytes) -> gsize;
    pub fn g_bytes_ref(bytes: *mut GBytes) -> *mut GBytes;
    pub fn g_bytes_unref(bytes: *mut GBytes) -> ();
    pub fn g_bytes_unref_to_data(bytes: *mut GBytes, size: *mut gsize)
     -> gpointer;
    pub fn g_bytes_unref_to_array(bytes: *mut GBytes) -> *mut GByteArray;
    pub fn g_bytes_hash(bytes: gconstpointer) -> guint;
    pub fn g_bytes_equal(bytes1: gconstpointer, bytes2: gconstpointer)
     -> gboolean;
    pub fn g_bytes_compare(bytes1: gconstpointer, bytes2: gconstpointer)
     -> gint;
    pub fn g_get_charset(charset: *mut *const ::libc::c_char) -> gboolean;
    pub fn g_get_codeset() -> *mut gchar;
    pub fn g_get_language_names() -> *const *const gchar;
    pub fn g_get_locale_variants(locale: *const gchar) -> *mut *mut gchar;
    pub fn g_checksum_type_get_length(checksum_type: GChecksumType) -> gssize;
    pub fn g_checksum_new(checksum_type: GChecksumType) -> *mut GChecksum;
    pub fn g_checksum_reset(checksum: *mut GChecksum) -> ();
    pub fn g_checksum_copy(checksum: *const GChecksum) -> *mut GChecksum;
    pub fn g_checksum_free(checksum: *mut GChecksum) -> ();
    pub fn g_checksum_update(checksum: *mut GChecksum, data: *const guchar,
                             length: gssize) -> ();
    pub fn g_checksum_get_string(checksum: *mut GChecksum) -> *const gchar;
    pub fn g_checksum_get_digest(checksum: *mut GChecksum,
                                 buffer: *mut guint8, digest_len: *mut gsize)
     -> ();
    pub fn g_compute_checksum_for_data(checksum_type: GChecksumType,
                                       data: *const guchar, length: gsize)
     -> *mut gchar;
    pub fn g_compute_checksum_for_string(checksum_type: GChecksumType,
                                         str: *const gchar, length: gssize)
     -> *mut gchar;
    pub fn g_compute_checksum_for_bytes(checksum_type: GChecksumType,
                                        data: *mut GBytes) -> *mut gchar;
    pub fn g_convert_error_quark() -> GQuark;
    pub fn g_iconv_open(to_codeset: *const gchar, from_codeset: *const gchar)
     -> GIConv;
    pub fn g_iconv(converter: GIConv, inbuf: *mut *mut gchar,
                   inbytes_left: *mut gsize, outbuf: *mut *mut gchar,
                   outbytes_left: *mut gsize) -> gsize;
    pub fn g_iconv_close(converter: GIConv) -> gint;
    pub fn g_convert(str: *const gchar, len: gssize, to_codeset: *const gchar,
                     from_codeset: *const gchar, bytes_read: *mut gsize,
                     bytes_written: *mut gsize, error: *mut *mut GError)
     -> *mut gchar;
    pub fn g_convert_with_iconv(str: *const gchar, len: gssize,
                                converter: GIConv, bytes_read: *mut gsize,
                                bytes_written: *mut gsize,
                                error: *mut *mut GError) -> *mut gchar;
    pub fn g_convert_with_fallback(str: *const gchar, len: gssize,
                                   to_codeset: *const gchar,
                                   from_codeset: *const gchar,
                                   fallback: *const gchar,
                                   bytes_read: *mut gsize,
                                   bytes_written: *mut gsize,
                                   error: *mut *mut GError) -> *mut gchar;
    pub fn g_locale_to_utf8(opsysstring: *const gchar, len: gssize,
                            bytes_read: *mut gsize, bytes_written: *mut gsize,
                            error: *mut *mut GError) -> *mut gchar;
    pub fn g_locale_from_utf8(utf8string: *const gchar, len: gssize,
                              bytes_read: *mut gsize,
                              bytes_written: *mut gsize,
                              error: *mut *mut GError) -> *mut gchar;
    pub fn g_filename_to_utf8(opsysstring: *const gchar, len: gssize,
                              bytes_read: *mut gsize,
                              bytes_written: *mut gsize,
                              error: *mut *mut GError) -> *mut gchar;
    pub fn g_filename_from_utf8(utf8string: *const gchar, len: gssize,
                                bytes_read: *mut gsize,
                                bytes_written: *mut gsize,
                                error: *mut *mut GError) -> *mut gchar;
    pub fn g_filename_from_uri(uri: *const gchar, hostname: *mut *mut gchar,
                               error: *mut *mut GError) -> *mut gchar;
    pub fn g_filename_to_uri(filename: *const gchar, hostname: *const gchar,
                             error: *mut *mut GError) -> *mut gchar;
    pub fn g_filename_display_name(filename: *const gchar) -> *mut gchar;
    pub fn g_get_filename_charsets(charsets: *mut *mut *const gchar)
     -> gboolean;
    pub fn g_filename_display_basename(filename: *const gchar) -> *mut gchar;
    pub fn g_uri_list_extract_uris(uri_list: *const gchar) -> *mut *mut gchar;
    pub fn g_datalist_init(datalist: *mut *mut GData) -> ();
    pub fn g_datalist_clear(datalist: *mut *mut GData) -> ();
    pub fn g_datalist_id_get_data(datalist: *mut *mut GData, key_id: GQuark)
     -> gpointer;
    pub fn g_datalist_id_set_data_full(datalist: *mut *mut GData,
                                       key_id: GQuark, data: gpointer,
                                       destroy_func: GDestroyNotify) -> ();
    pub fn g_datalist_id_dup_data(datalist: *mut *mut GData, key_id: GQuark,
                                  dup_func: GDuplicateFunc,
                                  user_data: gpointer) -> gpointer;
    pub fn g_datalist_id_replace_data(datalist: *mut *mut GData,
                                      key_id: GQuark, oldval: gpointer,
                                      newval: gpointer,
                                      destroy: GDestroyNotify,
                                      old_destroy: *mut GDestroyNotify)
     -> gboolean;
    pub fn g_datalist_id_remove_no_notify(datalist: *mut *mut GData,
                                          key_id: GQuark) -> gpointer;
    pub fn g_datalist_foreach(datalist: *mut *mut GData,
                              func: GDataForeachFunc, user_data: gpointer)
     -> ();
    pub fn g_datalist_set_flags(datalist: *mut *mut GData, flags: guint)
     -> ();
    pub fn g_datalist_unset_flags(datalist: *mut *mut GData, flags: guint)
     -> ();
    pub fn g_datalist_get_flags(datalist: *mut *mut GData) -> guint;
    pub fn g_dataset_destroy(dataset_location: gconstpointer) -> ();
    pub fn g_dataset_id_get_data(dataset_location: gconstpointer,
                                 key_id: GQuark) -> gpointer;
    pub fn g_datalist_get_data(datalist: *mut *mut GData, key: *const gchar)
     -> gpointer;
    pub fn g_dataset_id_set_data_full(dataset_location: gconstpointer,
                                      key_id: GQuark, data: gpointer,
                                      destroy_func: GDestroyNotify) -> ();
    pub fn g_dataset_id_remove_no_notify(dataset_location: gconstpointer,
                                         key_id: GQuark) -> gpointer;
    pub fn g_dataset_foreach(dataset_location: gconstpointer,
                             func: GDataForeachFunc, user_data: gpointer)
     -> ();
    pub fn g_date_new() -> *mut GDate;
    pub fn g_date_new_dmy(day: GDateDay, month: GDateMonth, year: GDateYear)
     -> *mut GDate;
    pub fn g_date_new_julian(julian_day: guint32) -> *mut GDate;
    pub fn g_date_free(date: *mut GDate) -> ();
    pub fn g_date_valid(date: *const GDate) -> gboolean;
    pub fn g_date_valid_day(day: GDateDay) -> gboolean;
    pub fn g_date_valid_month(month: GDateMonth) -> gboolean;
    pub fn g_date_valid_year(year: GDateYear) -> gboolean;
    pub fn g_date_valid_weekday(weekday: GDateWeekday) -> gboolean;
    pub fn g_date_valid_julian(julian_date: guint32) -> gboolean;
    pub fn g_date_valid_dmy(day: GDateDay, month: GDateMonth, year: GDateYear)
     -> gboolean;
    pub fn g_date_get_weekday(date: *const GDate) -> GDateWeekday;
    pub fn g_date_get_month(date: *const GDate) -> GDateMonth;
    pub fn g_date_get_year(date: *const GDate) -> GDateYear;
    pub fn g_date_get_day(date: *const GDate) -> GDateDay;
    pub fn g_date_get_julian(date: *const GDate) -> guint32;
    pub fn g_date_get_day_of_year(date: *const GDate) -> guint;
    pub fn g_date_get_monday_week_of_year(date: *const GDate) -> guint;
    pub fn g_date_get_sunday_week_of_year(date: *const GDate) -> guint;
    pub fn g_date_get_iso8601_week_of_year(date: *const GDate) -> guint;
    pub fn g_date_clear(date: *mut GDate, n_dates: guint) -> ();
    pub fn g_date_set_parse(date: *mut GDate, str: *const gchar) -> ();
    pub fn g_date_set_time_t(date: *mut GDate, timet: time_t) -> ();
    pub fn g_date_set_time_val(date: *mut GDate, timeval: *mut GTimeVal)
     -> ();
    pub fn g_date_set_time(date: *mut GDate, time_: GTime) -> ();
    pub fn g_date_set_month(date: *mut GDate, month: GDateMonth) -> ();
    pub fn g_date_set_day(date: *mut GDate, day: GDateDay) -> ();
    pub fn g_date_set_year(date: *mut GDate, year: GDateYear) -> ();
    pub fn g_date_set_dmy(date: *mut GDate, day: GDateDay, month: GDateMonth,
                          y: GDateYear) -> ();
    pub fn g_date_set_julian(date: *mut GDate, julian_date: guint32) -> ();
    pub fn g_date_is_first_of_month(date: *const GDate) -> gboolean;
    pub fn g_date_is_last_of_month(date: *const GDate) -> gboolean;
    pub fn g_date_add_days(date: *mut GDate, n_days: guint) -> ();
    pub fn g_date_subtract_days(date: *mut GDate, n_days: guint) -> ();
    pub fn g_date_add_months(date: *mut GDate, n_months: guint) -> ();
    pub fn g_date_subtract_months(date: *mut GDate, n_months: guint) -> ();
    pub fn g_date_add_years(date: *mut GDate, n_years: guint) -> ();
    pub fn g_date_subtract_years(date: *mut GDate, n_years: guint) -> ();
    pub fn g_date_is_leap_year(year: GDateYear) -> gboolean;
    pub fn g_date_get_days_in_month(month: GDateMonth, year: GDateYear)
     -> guint8;
    pub fn g_date_get_monday_weeks_in_year(year: GDateYear) -> guint8;
    pub fn g_date_get_sunday_weeks_in_year(year: GDateYear) -> guint8;
    pub fn g_date_days_between(date1: *const GDate, date2: *const GDate)
     -> gint;
    pub fn g_date_compare(lhs: *const GDate, rhs: *const GDate) -> gint;
    pub fn g_date_to_struct_tm(date: *const GDate, tm: *mut Struct_tm) -> ();
    pub fn g_date_clamp(date: *mut GDate, min_date: *const GDate,
                        max_date: *const GDate) -> ();
    pub fn g_date_order(date1: *mut GDate, date2: *mut GDate) -> ();
    pub fn g_date_strftime(s: *mut gchar, slen: gsize, format: *const gchar,
                           date: *const GDate) -> gsize;
    pub fn g_time_zone_new(identifier: *const gchar) -> *mut GTimeZone;
    pub fn g_time_zone_new_utc() -> *mut GTimeZone;
    pub fn g_time_zone_new_local() -> *mut GTimeZone;
    pub fn g_time_zone_ref(tz: *mut GTimeZone) -> *mut GTimeZone;
    pub fn g_time_zone_unref(tz: *mut GTimeZone) -> ();
    pub fn g_time_zone_find_interval(tz: *mut GTimeZone, _type: GTimeType,
                                     time_: gint64) -> gint;
    pub fn g_time_zone_adjust_time(tz: *mut GTimeZone, _type: GTimeType,
                                   time_: *mut gint64) -> gint;
    pub fn g_time_zone_get_abbreviation(tz: *mut GTimeZone, interval: gint)
     -> *const gchar;
    pub fn g_time_zone_get_offset(tz: *mut GTimeZone, interval: gint)
     -> gint32;
    pub fn g_time_zone_is_dst(tz: *mut GTimeZone, interval: gint) -> gboolean;
    pub fn g_date_time_unref(datetime: *mut GDateTime) -> ();
    pub fn g_date_time_ref(datetime: *mut GDateTime) -> *mut GDateTime;
    pub fn g_date_time_new_now(tz: *mut GTimeZone) -> *mut GDateTime;
    pub fn g_date_time_new_now_local() -> *mut GDateTime;
    pub fn g_date_time_new_now_utc() -> *mut GDateTime;
    pub fn g_date_time_new_from_unix_local(t: gint64) -> *mut GDateTime;
    pub fn g_date_time_new_from_unix_utc(t: gint64) -> *mut GDateTime;
    pub fn g_date_time_new_from_timeval_local(tv: *const GTimeVal)
     -> *mut GDateTime;
    pub fn g_date_time_new_from_timeval_utc(tv: *const GTimeVal)
     -> *mut GDateTime;
    pub fn g_date_time_new(tz: *mut GTimeZone, year: gint, month: gint,
                           day: gint, hour: gint, minute: gint,
                           seconds: gdouble) -> *mut GDateTime;
    pub fn g_date_time_new_local(year: gint, month: gint, day: gint,
                                 hour: gint, minute: gint, seconds: gdouble)
     -> *mut GDateTime;
    pub fn g_date_time_new_utc(year: gint, month: gint, day: gint, hour: gint,
                               minute: gint, seconds: gdouble)
     -> *mut GDateTime;
    pub fn g_date_time_add(datetime: *mut GDateTime, timespan: GTimeSpan)
     -> *mut GDateTime;
    pub fn g_date_time_add_years(datetime: *mut GDateTime, years: gint)
     -> *mut GDateTime;
    pub fn g_date_time_add_months(datetime: *mut GDateTime, months: gint)
     -> *mut GDateTime;
    pub fn g_date_time_add_weeks(datetime: *mut GDateTime, weeks: gint)
     -> *mut GDateTime;
    pub fn g_date_time_add_days(datetime: *mut GDateTime, days: gint)
     -> *mut GDateTime;
    pub fn g_date_time_add_hours(datetime: *mut GDateTime, hours: gint)
     -> *mut GDateTime;
    pub fn g_date_time_add_minutes(datetime: *mut GDateTime, minutes: gint)
     -> *mut GDateTime;
    pub fn g_date_time_add_seconds(datetime: *mut GDateTime, seconds: gdouble)
     -> *mut GDateTime;
    pub fn g_date_time_add_full(datetime: *mut GDateTime, years: gint,
                                months: gint, days: gint, hours: gint,
                                minutes: gint, seconds: gdouble)
     -> *mut GDateTime;
    pub fn g_date_time_compare(dt1: gconstpointer, dt2: gconstpointer)
     -> gint;
    pub fn g_date_time_difference(end: *mut GDateTime, begin: *mut GDateTime)
     -> GTimeSpan;
    pub fn g_date_time_hash(datetime: gconstpointer) -> guint;
    pub fn g_date_time_equal(dt1: gconstpointer, dt2: gconstpointer)
     -> gboolean;
    pub fn g_date_time_get_ymd(datetime: *mut GDateTime, year: *mut gint,
                               month: *mut gint, day: *mut gint) -> ();
    pub fn g_date_time_get_year(datetime: *mut GDateTime) -> gint;
    pub fn g_date_time_get_month(datetime: *mut GDateTime) -> gint;
    pub fn g_date_time_get_day_of_month(datetime: *mut GDateTime) -> gint;
    pub fn g_date_time_get_week_numbering_year(datetime: *mut GDateTime)
     -> gint;
    pub fn g_date_time_get_week_of_year(datetime: *mut GDateTime) -> gint;
    pub fn g_date_time_get_day_of_week(datetime: *mut GDateTime) -> gint;
    pub fn g_date_time_get_day_of_year(datetime: *mut GDateTime) -> gint;
    pub fn g_date_time_get_hour(datetime: *mut GDateTime) -> gint;
    pub fn g_date_time_get_minute(datetime: *mut GDateTime) -> gint;
    pub fn g_date_time_get_second(datetime: *mut GDateTime) -> gint;
    pub fn g_date_time_get_microsecond(datetime: *mut GDateTime) -> gint;
    pub fn g_date_time_get_seconds(datetime: *mut GDateTime) -> gdouble;
    pub fn g_date_time_to_unix(datetime: *mut GDateTime) -> gint64;
    pub fn g_date_time_to_timeval(datetime: *mut GDateTime, tv: *mut GTimeVal)
     -> gboolean;
    pub fn g_date_time_get_utc_offset(datetime: *mut GDateTime) -> GTimeSpan;
    pub fn g_date_time_get_timezone_abbreviation(datetime: *mut GDateTime)
     -> *const gchar;
    pub fn g_date_time_is_daylight_savings(datetime: *mut GDateTime)
     -> gboolean;
    pub fn g_date_time_to_timezone(datetime: *mut GDateTime,
                                   tz: *mut GTimeZone) -> *mut GDateTime;
    pub fn g_date_time_to_local(datetime: *mut GDateTime) -> *mut GDateTime;
    pub fn g_date_time_to_utc(datetime: *mut GDateTime) -> *mut GDateTime;
    pub fn g_date_time_format(datetime: *mut GDateTime, format: *const gchar)
     -> *mut gchar;
    pub fn opendir(__name: *const ::libc::c_char) -> *mut DIR;
    pub fn fdopendir(__fd: ::libc::c_int) -> *mut DIR;
    pub fn closedir(__dirp: *mut DIR) -> ::libc::c_int;
    pub fn readdir(__dirp: *mut DIR) -> *mut Struct_dirent;
    pub fn readdir_r(__dirp: *mut DIR, __entry: *mut Struct_dirent,
                     __result: *mut *mut Struct_dirent) -> ::libc::c_int;
    pub fn rewinddir(__dirp: *mut DIR) -> ();
    pub fn seekdir(__dirp: *mut DIR, __pos: ::libc::c_long) -> ();
    pub fn telldir(__dirp: *mut DIR) -> ::libc::c_long;
    pub fn dirfd(__dirp: *mut DIR) -> ::libc::c_int;
    pub fn scandir(__dir: *const ::libc::c_char,
                   __namelist: *mut *mut *mut Struct_dirent,
                   __selector:
                       ::std::option::Option<extern "C" fn(arg1:
                                                               *const Struct_dirent)
                                                 -> ::libc::c_int>,
                   __cmp:
                       ::std::option::Option<extern "C" fn(arg1:
                                                               *mut *const Struct_dirent,
                                                           arg2:
                                                               *mut *const Struct_dirent)
                                                 -> ::libc::c_int>)
     -> ::libc::c_int;
    pub fn alphasort(__e1: *mut *const Struct_dirent,
                     __e2: *mut *const Struct_dirent) -> ::libc::c_int;
    pub fn getdirentries(__fd: ::libc::c_int, __buf: *mut ::libc::c_char,
                         __nbytes: size_t, __basep: *mut __off_t)
     -> __ssize_t;
    pub fn g_dir_open(path: *const gchar, flags: guint,
                      error: *mut *mut GError) -> *mut GDir;
    pub fn g_dir_read_name(dir: *mut GDir) -> *const gchar;
    pub fn g_dir_rewind(dir: *mut GDir) -> ();
    pub fn g_dir_close(dir: *mut GDir) -> ();
    pub fn g_getenv(variable: *const gchar) -> *const gchar;
    pub fn g_setenv(variable: *const gchar, value: *const gchar,
                    overwrite: gboolean) -> gboolean;
    pub fn g_unsetenv(variable: *const gchar) -> ();
    pub fn g_listenv() -> *mut *mut gchar;
    pub fn g_get_environ() -> *mut *mut gchar;
    pub fn g_environ_getenv(envp: *mut *mut gchar, variable: *const gchar)
     -> *const gchar;
    pub fn g_environ_setenv(envp: *mut *mut gchar, variable: *const gchar,
                            value: *const gchar, overwrite: gboolean)
     -> *mut *mut gchar;
    pub fn g_environ_unsetenv(envp: *mut *mut gchar, variable: *const gchar)
     -> *mut *mut gchar;
    pub fn g_file_error_quark() -> GQuark;
    pub fn g_file_error_from_errno(err_no: gint) -> GFileError;
    pub fn g_file_test(filename: *const gchar, test: GFileTest) -> gboolean;
    pub fn g_file_get_contents(filename: *const gchar,
                               contents: *mut *mut gchar, length: *mut gsize,
                               error: *mut *mut GError) -> gboolean;
    pub fn g_file_set_contents(filename: *const gchar, contents: *const gchar,
                               length: gssize, error: *mut *mut GError)
     -> gboolean;
    pub fn g_file_read_link(filename: *const gchar, error: *mut *mut GError)
     -> *mut gchar;
    pub fn g_mkdtemp(tmpl: *mut gchar) -> *mut gchar;
    pub fn g_mkdtemp_full(tmpl: *mut gchar, mode: gint) -> *mut gchar;
    pub fn g_mkstemp(tmpl: *mut gchar) -> gint;
    pub fn g_mkstemp_full(tmpl: *mut gchar, flags: gint, mode: gint) -> gint;
    pub fn g_file_open_tmp(tmpl: *const gchar, name_used: *mut *mut gchar,
                           error: *mut *mut GError) -> gint;
    pub fn g_dir_make_tmp(tmpl: *const gchar, error: *mut *mut GError)
     -> *mut gchar;
    pub fn g_build_path(separator: *const gchar,
                        first_element: *const gchar, ...) -> *mut gchar;
    pub fn g_build_pathv(separator: *const gchar, args: *mut *mut gchar)
     -> *mut gchar;
    pub fn g_build_filename(first_element: *const gchar, ...) -> *mut gchar;
    pub fn g_build_filenamev(args: *mut *mut gchar) -> *mut gchar;
    pub fn g_mkdir_with_parents(pathname: *const gchar, mode: gint) -> gint;
    pub fn g_path_is_absolute(file_name: *const gchar) -> gboolean;
    pub fn g_path_skip_root(file_name: *const gchar) -> *const gchar;
    pub fn g_basename(file_name: *const gchar) -> *const gchar;
    pub fn g_get_current_dir() -> *mut gchar;
    pub fn g_path_get_basename(file_name: *const gchar) -> *mut gchar;
    pub fn g_path_get_dirname(file_name: *const gchar) -> *mut gchar;
    pub fn g_strip_context(msgid: *const gchar, msgval: *const gchar)
     -> *const gchar;
    pub fn g_dgettext(domain: *const gchar, msgid: *const gchar)
     -> *const gchar;
    pub fn g_dcgettext(domain: *const gchar, msgid: *const gchar,
                       category: gint) -> *const gchar;
    pub fn g_dngettext(domain: *const gchar, msgid: *const gchar,
                       msgid_plural: *const gchar, n: gulong) -> *const gchar;
    pub fn g_dpgettext(domain: *const gchar, msgctxtid: *const gchar,
                       msgidoffset: gsize) -> *const gchar;
    pub fn g_dpgettext2(domain: *const gchar, context: *const gchar,
                        msgid: *const gchar) -> *const gchar;
    pub fn g_free(mem: gpointer) -> ();
    pub fn g_clear_pointer(pp: *mut gpointer, destroy: GDestroyNotify) -> ();
    pub fn g_malloc(n_bytes: gsize) -> gpointer;
    pub fn g_malloc0(n_bytes: gsize) -> gpointer;
    pub fn g_realloc(mem: gpointer, n_bytes: gsize) -> gpointer;
    pub fn g_try_malloc(n_bytes: gsize) -> gpointer;
    pub fn g_try_malloc0(n_bytes: gsize) -> gpointer;
    pub fn g_try_realloc(mem: gpointer, n_bytes: gsize) -> gpointer;
    pub fn g_malloc_n(n_blocks: gsize, n_block_bytes: gsize) -> gpointer;
    pub fn g_malloc0_n(n_blocks: gsize, n_block_bytes: gsize) -> gpointer;
    pub fn g_realloc_n(mem: gpointer, n_blocks: gsize, n_block_bytes: gsize)
     -> gpointer;
    pub fn g_try_malloc_n(n_blocks: gsize, n_block_bytes: gsize) -> gpointer;
    pub fn g_try_malloc0_n(n_blocks: gsize, n_block_bytes: gsize) -> gpointer;
    pub fn g_try_realloc_n(mem: gpointer, n_blocks: gsize,
                           n_block_bytes: gsize) -> gpointer;
    pub fn g_mem_set_vtable(vtable: *mut GMemVTable) -> ();
    pub fn g_mem_is_system_malloc() -> gboolean;
    pub fn g_mem_profile() -> ();
    pub fn g_node_new(data: gpointer) -> *mut GNode;
    pub fn g_node_destroy(root: *mut GNode) -> ();
    pub fn g_node_unlink(node: *mut GNode) -> ();
    pub fn g_node_copy_deep(node: *mut GNode, copy_func: GCopyFunc,
                            data: gpointer) -> *mut GNode;
    pub fn g_node_copy(node: *mut GNode) -> *mut GNode;
    pub fn g_node_insert(parent: *mut GNode, position: gint, node: *mut GNode)
     -> *mut GNode;
    pub fn g_node_insert_before(parent: *mut GNode, sibling: *mut GNode,
                                node: *mut GNode) -> *mut GNode;
    pub fn g_node_insert_after(parent: *mut GNode, sibling: *mut GNode,
                               node: *mut GNode) -> *mut GNode;
    pub fn g_node_prepend(parent: *mut GNode, node: *mut GNode) -> *mut GNode;
    pub fn g_node_n_nodes(root: *mut GNode, flags: GTraverseFlags) -> guint;
    pub fn g_node_get_root(node: *mut GNode) -> *mut GNode;
    pub fn g_node_is_ancestor(node: *mut GNode, descendant: *mut GNode)
     -> gboolean;
    pub fn g_node_depth(node: *mut GNode) -> guint;
    pub fn g_node_find(root: *mut GNode, order: GTraverseType,
                       flags: GTraverseFlags, data: gpointer) -> *mut GNode;
    pub fn g_node_traverse(root: *mut GNode, order: GTraverseType,
                           flags: GTraverseFlags, max_depth: gint,
                           func: GNodeTraverseFunc, data: gpointer) -> ();
    pub fn g_node_max_height(root: *mut GNode) -> guint;
    pub fn g_node_children_foreach(node: *mut GNode, flags: GTraverseFlags,
                                   func: GNodeForeachFunc, data: gpointer)
     -> ();
    pub fn g_node_reverse_children(node: *mut GNode) -> ();
    pub fn g_node_n_children(node: *mut GNode) -> guint;
    pub fn g_node_nth_child(node: *mut GNode, n: guint) -> *mut GNode;
    pub fn g_node_last_child(node: *mut GNode) -> *mut GNode;
    pub fn g_node_find_child(node: *mut GNode, flags: GTraverseFlags,
                             data: gpointer) -> *mut GNode;
    pub fn g_node_child_position(node: *mut GNode, child: *mut GNode) -> gint;
    pub fn g_node_child_index(node: *mut GNode, data: gpointer) -> gint;
    pub fn g_node_first_sibling(node: *mut GNode) -> *mut GNode;
    pub fn g_node_last_sibling(node: *mut GNode) -> *mut GNode;
    pub fn g_list_alloc() -> *mut GList;
    pub fn g_list_free(list: *mut GList) -> ();
    pub fn g_list_free_1(list: *mut GList) -> ();
    pub fn g_list_free_full(list: *mut GList, free_func: GDestroyNotify)
     -> ();
    pub fn g_list_append(list: *mut GList, data: gpointer) -> *mut GList;
    pub fn g_list_prepend(list: *mut GList, data: gpointer) -> *mut GList;
    pub fn g_list_insert(list: *mut GList, data: gpointer, position: gint)
     -> *mut GList;
    pub fn g_list_insert_sorted(list: *mut GList, data: gpointer,
                                func: GCompareFunc) -> *mut GList;
    pub fn g_list_insert_sorted_with_data(list: *mut GList, data: gpointer,
                                          func: GCompareDataFunc,
                                          user_data: gpointer) -> *mut GList;
    pub fn g_list_insert_before(list: *mut GList, sibling: *mut GList,
                                data: gpointer) -> *mut GList;
    pub fn g_list_concat(list1: *mut GList, list2: *mut GList) -> *mut GList;
    pub fn g_list_remove(list: *mut GList, data: gconstpointer) -> *mut GList;
    pub fn g_list_remove_all(list: *mut GList, data: gconstpointer)
     -> *mut GList;
    pub fn g_list_remove_link(list: *mut GList, llink: *mut GList)
     -> *mut GList;
    pub fn g_list_delete_link(list: *mut GList, link_: *mut GList)
     -> *mut GList;
    pub fn g_list_reverse(list: *mut GList) -> *mut GList;
    pub fn g_list_copy(list: *mut GList) -> *mut GList;
    pub fn g_list_copy_deep(list: *mut GList, func: GCopyFunc,
                            user_data: gpointer) -> *mut GList;
    pub fn g_list_nth(list: *mut GList, n: guint) -> *mut GList;
    pub fn g_list_nth_prev(list: *mut GList, n: guint) -> *mut GList;
    pub fn g_list_find(list: *mut GList, data: gconstpointer) -> *mut GList;
    pub fn g_list_find_custom(list: *mut GList, data: gconstpointer,
                              func: GCompareFunc) -> *mut GList;
    pub fn g_list_position(list: *mut GList, llink: *mut GList) -> gint;
    pub fn g_list_index(list: *mut GList, data: gconstpointer) -> gint;
    pub fn g_list_last(list: *mut GList) -> *mut GList;
    pub fn g_list_first(list: *mut GList) -> *mut GList;
    pub fn g_list_length(list: *mut GList) -> guint;
    pub fn g_list_foreach(list: *mut GList, func: GFunc, user_data: gpointer)
     -> ();
    pub fn g_list_sort(list: *mut GList, compare_func: GCompareFunc)
     -> *mut GList;
    pub fn g_list_sort_with_data(list: *mut GList,
                                 compare_func: GCompareDataFunc,
                                 user_data: gpointer) -> *mut GList;
    pub fn g_list_nth_data(list: *mut GList, n: guint) -> gpointer;
    pub fn g_hash_table_new(hash_func: GHashFunc, key_equal_func: GEqualFunc)
     -> *mut GHashTable;
    pub fn g_hash_table_new_full(hash_func: GHashFunc,
                                 key_equal_func: GEqualFunc,
                                 key_destroy_func: GDestroyNotify,
                                 value_destroy_func: GDestroyNotify)
     -> *mut GHashTable;
    pub fn g_hash_table_destroy(hash_table: *mut GHashTable) -> ();
    pub fn g_hash_table_insert(hash_table: *mut GHashTable, key: gpointer,
                               value: gpointer) -> gboolean;
    pub fn g_hash_table_replace(hash_table: *mut GHashTable, key: gpointer,
                                value: gpointer) -> gboolean;
    pub fn g_hash_table_add(hash_table: *mut GHashTable, key: gpointer)
     -> gboolean;
    pub fn g_hash_table_remove(hash_table: *mut GHashTable,
                               key: gconstpointer) -> gboolean;
    pub fn g_hash_table_remove_all(hash_table: *mut GHashTable) -> ();
    pub fn g_hash_table_steal(hash_table: *mut GHashTable, key: gconstpointer)
     -> gboolean;
    pub fn g_hash_table_steal_all(hash_table: *mut GHashTable) -> ();
    pub fn g_hash_table_lookup(hash_table: *mut GHashTable,
                               key: gconstpointer) -> gpointer;
    pub fn g_hash_table_contains(hash_table: *mut GHashTable,
                                 key: gconstpointer) -> gboolean;
    pub fn g_hash_table_lookup_extended(hash_table: *mut GHashTable,
                                        lookup_key: gconstpointer,
                                        orig_key: *mut gpointer,
                                        value: *mut gpointer) -> gboolean;
    pub fn g_hash_table_foreach(hash_table: *mut GHashTable, func: GHFunc,
                                user_data: gpointer) -> ();
    pub fn g_hash_table_find(hash_table: *mut GHashTable, predicate: GHRFunc,
                             user_data: gpointer) -> gpointer;
    pub fn g_hash_table_foreach_remove(hash_table: *mut GHashTable,
                                       func: GHRFunc, user_data: gpointer)
     -> guint;
    pub fn g_hash_table_foreach_steal(hash_table: *mut GHashTable,
                                      func: GHRFunc, user_data: gpointer)
     -> guint;
    pub fn g_hash_table_size(hash_table: *mut GHashTable) -> guint;
    pub fn g_hash_table_get_keys(hash_table: *mut GHashTable) -> *mut GList;
    pub fn g_hash_table_get_values(hash_table: *mut GHashTable) -> *mut GList;
    pub fn g_hash_table_get_keys_as_array(hash_table: *mut GHashTable,
                                          length: *mut guint)
     -> *mut gpointer;
    pub fn g_hash_table_iter_init(iter: *mut GHashTableIter,
                                  hash_table: *mut GHashTable) -> ();
    pub fn g_hash_table_iter_next(iter: *mut GHashTableIter,
                                  key: *mut gpointer, value: *mut gpointer)
     -> gboolean;
    pub fn g_hash_table_iter_get_hash_table(iter: *mut GHashTableIter)
     -> *mut GHashTable;
    pub fn g_hash_table_iter_remove(iter: *mut GHashTableIter) -> ();
    pub fn g_hash_table_iter_replace(iter: *mut GHashTableIter,
                                     value: gpointer) -> ();
    pub fn g_hash_table_iter_steal(iter: *mut GHashTableIter) -> ();
    pub fn g_hash_table_ref(hash_table: *mut GHashTable) -> *mut GHashTable;
    pub fn g_hash_table_unref(hash_table: *mut GHashTable) -> ();
    pub fn g_str_equal(v1: gconstpointer, v2: gconstpointer) -> gboolean;
    pub fn g_str_hash(v: gconstpointer) -> guint;
    pub fn g_int_equal(v1: gconstpointer, v2: gconstpointer) -> gboolean;
    pub fn g_int_hash(v: gconstpointer) -> guint;
    pub fn g_int64_equal(v1: gconstpointer, v2: gconstpointer) -> gboolean;
    pub fn g_int64_hash(v: gconstpointer) -> guint;
    pub fn g_double_equal(v1: gconstpointer, v2: gconstpointer) -> gboolean;
    pub fn g_double_hash(v: gconstpointer) -> guint;
    pub fn g_direct_hash(v: gconstpointer) -> guint;
    pub fn g_direct_equal(v1: gconstpointer, v2: gconstpointer) -> gboolean;
    pub fn g_hmac_new(digest_type: GChecksumType, key: *const guchar,
                      key_len: gsize) -> *mut GHmac;
    pub fn g_hmac_copy(hmac: *const GHmac) -> *mut GHmac;
    pub fn g_hmac_ref(hmac: *mut GHmac) -> *mut GHmac;
    pub fn g_hmac_unref(hmac: *mut GHmac) -> ();
    pub fn g_hmac_update(hmac: *mut GHmac, data: *const guchar,
                         length: gssize) -> ();
    pub fn g_hmac_get_string(hmac: *mut GHmac) -> *const gchar;
    pub fn g_hmac_get_digest(hmac: *mut GHmac, buffer: *mut guint8,
                             digest_len: *mut gsize) -> ();
    pub fn g_compute_hmac_for_data(digest_type: GChecksumType,
                                   key: *const guchar, key_len: gsize,
                                   data: *const guchar, length: gsize)
     -> *mut gchar;
    pub fn g_compute_hmac_for_string(digest_type: GChecksumType,
                                     key: *const guchar, key_len: gsize,
                                     str: *const gchar, length: gssize)
     -> *mut gchar;
    pub fn g_hook_list_init(hook_list: *mut GHookList, hook_size: guint)
     -> ();
    pub fn g_hook_list_clear(hook_list: *mut GHookList) -> ();
    pub fn g_hook_alloc(hook_list: *mut GHookList) -> *mut GHook;
    pub fn g_hook_free(hook_list: *mut GHookList, hook: *mut GHook) -> ();
    pub fn g_hook_ref(hook_list: *mut GHookList, hook: *mut GHook)
     -> *mut GHook;
    pub fn g_hook_unref(hook_list: *mut GHookList, hook: *mut GHook) -> ();
    pub fn g_hook_destroy(hook_list: *mut GHookList, hook_id: gulong)
     -> gboolean;
    pub fn g_hook_destroy_link(hook_list: *mut GHookList, hook: *mut GHook)
     -> ();
    pub fn g_hook_prepend(hook_list: *mut GHookList, hook: *mut GHook) -> ();
    pub fn g_hook_insert_before(hook_list: *mut GHookList,
                                sibling: *mut GHook, hook: *mut GHook) -> ();
    pub fn g_hook_insert_sorted(hook_list: *mut GHookList, hook: *mut GHook,
                                func: GHookCompareFunc) -> ();
    pub fn g_hook_get(hook_list: *mut GHookList, hook_id: gulong)
     -> *mut GHook;
    pub fn g_hook_find(hook_list: *mut GHookList, need_valids: gboolean,
                       func: GHookFindFunc, data: gpointer) -> *mut GHook;
    pub fn g_hook_find_data(hook_list: *mut GHookList, need_valids: gboolean,
                            data: gpointer) -> *mut GHook;
    pub fn g_hook_find_func(hook_list: *mut GHookList, need_valids: gboolean,
                            func: gpointer) -> *mut GHook;
    pub fn g_hook_find_func_data(hook_list: *mut GHookList,
                                 need_valids: gboolean, func: gpointer,
                                 data: gpointer) -> *mut GHook;
    pub fn g_hook_first_valid(hook_list: *mut GHookList,
                              may_be_in_call: gboolean) -> *mut GHook;
    pub fn g_hook_next_valid(hook_list: *mut GHookList, hook: *mut GHook,
                             may_be_in_call: gboolean) -> *mut GHook;
    pub fn g_hook_compare_ids(new_hook: *mut GHook, sibling: *mut GHook)
     -> gint;
    pub fn g_hook_list_invoke(hook_list: *mut GHookList,
                              may_recurse: gboolean) -> ();
    pub fn g_hook_list_invoke_check(hook_list: *mut GHookList,
                                    may_recurse: gboolean) -> ();
    pub fn g_hook_list_marshal(hook_list: *mut GHookList,
                               may_recurse: gboolean,
                               marshaller: GHookMarshaller,
                               marshal_data: gpointer) -> ();
    pub fn g_hook_list_marshal_check(hook_list: *mut GHookList,
                                     may_recurse: gboolean,
                                     marshaller: GHookCheckMarshaller,
                                     marshal_data: gpointer) -> ();
    pub fn g_hostname_is_non_ascii(hostname: *const gchar) -> gboolean;
    pub fn g_hostname_is_ascii_encoded(hostname: *const gchar) -> gboolean;
    pub fn g_hostname_is_ip_address(hostname: *const gchar) -> gboolean;
    pub fn g_hostname_to_ascii(hostname: *const gchar) -> *mut gchar;
    pub fn g_hostname_to_unicode(hostname: *const gchar) -> *mut gchar;
    pub fn g_poll(fds: *mut GPollFD, nfds: guint, timeout: gint) -> gint;
    pub fn g_slist_alloc() -> *mut GSList;
    pub fn g_slist_free(list: *mut GSList) -> ();
    pub fn g_slist_free_1(list: *mut GSList) -> ();
    pub fn g_slist_free_full(list: *mut GSList, free_func: GDestroyNotify)
     -> ();
    pub fn g_slist_append(list: *mut GSList, data: gpointer) -> *mut GSList;
    pub fn g_slist_prepend(list: *mut GSList, data: gpointer) -> *mut GSList;
    pub fn g_slist_insert(list: *mut GSList, data: gpointer, position: gint)
     -> *mut GSList;
    pub fn g_slist_insert_sorted(list: *mut GSList, data: gpointer,
                                 func: GCompareFunc) -> *mut GSList;
    pub fn g_slist_insert_sorted_with_data(list: *mut GSList, data: gpointer,
                                           func: GCompareDataFunc,
                                           user_data: gpointer)
     -> *mut GSList;
    pub fn g_slist_insert_before(slist: *mut GSList, sibling: *mut GSList,
                                 data: gpointer) -> *mut GSList;
    pub fn g_slist_concat(list1: *mut GSList, list2: *mut GSList)
     -> *mut GSList;
    pub fn g_slist_remove(list: *mut GSList, data: gconstpointer)
     -> *mut GSList;
    pub fn g_slist_remove_all(list: *mut GSList, data: gconstpointer)
     -> *mut GSList;
    pub fn g_slist_remove_link(list: *mut GSList, link_: *mut GSList)
     -> *mut GSList;
    pub fn g_slist_delete_link(list: *mut GSList, link_: *mut GSList)
     -> *mut GSList;
    pub fn g_slist_reverse(list: *mut GSList) -> *mut GSList;
    pub fn g_slist_copy(list: *mut GSList) -> *mut GSList;
    pub fn g_slist_copy_deep(list: *mut GSList, func: GCopyFunc,
                             user_data: gpointer) -> *mut GSList;
    pub fn g_slist_nth(list: *mut GSList, n: guint) -> *mut GSList;
    pub fn g_slist_find(list: *mut GSList, data: gconstpointer)
     -> *mut GSList;
    pub fn g_slist_find_custom(list: *mut GSList, data: gconstpointer,
                               func: GCompareFunc) -> *mut GSList;
    pub fn g_slist_position(list: *mut GSList, llink: *mut GSList) -> gint;
    pub fn g_slist_index(list: *mut GSList, data: gconstpointer) -> gint;
    pub fn g_slist_last(list: *mut GSList) -> *mut GSList;
    pub fn g_slist_length(list: *mut GSList) -> guint;
    pub fn g_slist_foreach(list: *mut GSList, func: GFunc,
                           user_data: gpointer) -> ();
    pub fn g_slist_sort(list: *mut GSList, compare_func: GCompareFunc)
     -> *mut GSList;
    pub fn g_slist_sort_with_data(list: *mut GSList,
                                  compare_func: GCompareDataFunc,
                                  user_data: gpointer) -> *mut GSList;
    pub fn g_slist_nth_data(list: *mut GSList, n: guint) -> gpointer;
    pub fn g_main_context_new() -> *mut GMainContext;
    pub fn g_main_context_ref(context: *mut GMainContext)
     -> *mut GMainContext;
    pub fn g_main_context_unref(context: *mut GMainContext) -> ();
    pub fn g_main_context_default() -> *mut GMainContext;
    pub fn g_main_context_iteration(context: *mut GMainContext,
                                    may_block: gboolean) -> gboolean;
    pub fn g_main_context_pending(context: *mut GMainContext) -> gboolean;
    pub fn g_main_context_find_source_by_id(context: *mut GMainContext,
                                            source_id: guint) -> *mut GSource;
    pub fn g_main_context_find_source_by_user_data(context: *mut GMainContext,
                                                   user_data: gpointer)
     -> *mut GSource;
    pub fn g_main_context_find_source_by_funcs_user_data(context:
                                                             *mut GMainContext,
                                                         funcs:
                                                             *mut GSourceFuncs,
                                                         user_data: gpointer)
     -> *mut GSource;
    pub fn g_main_context_wakeup(context: *mut GMainContext) -> ();
    pub fn g_main_context_acquire(context: *mut GMainContext) -> gboolean;
    pub fn g_main_context_release(context: *mut GMainContext) -> ();
    pub fn g_main_context_is_owner(context: *mut GMainContext) -> gboolean;
    pub fn g_main_context_wait(context: *mut GMainContext, cond: *mut GCond,
                               mutex: *mut GMutex) -> gboolean;
    pub fn g_main_context_prepare(context: *mut GMainContext,
                                  priority: *mut gint) -> gboolean;
    pub fn g_main_context_query(context: *mut GMainContext,
                                max_priority: gint, timeout_: *mut gint,
                                fds: *mut GPollFD, n_fds: gint) -> gint;
    pub fn g_main_context_check(context: *mut GMainContext,
                                max_priority: gint, fds: *mut GPollFD,
                                n_fds: gint) -> gint;
    pub fn g_main_context_dispatch(context: *mut GMainContext) -> ();
    pub fn g_main_context_set_poll_func(context: *mut GMainContext,
                                        func: GPollFunc) -> ();
    pub fn g_main_context_get_poll_func(context: *mut GMainContext)
     -> GPollFunc;
    pub fn g_main_context_add_poll(context: *mut GMainContext,
                                   fd: *mut GPollFD, priority: gint) -> ();
    pub fn g_main_context_remove_poll(context: *mut GMainContext,
                                      fd: *mut GPollFD) -> ();
    pub fn g_main_depth() -> gint;
    pub fn g_main_current_source() -> *mut GSource;
    pub fn g_main_context_push_thread_default(context: *mut GMainContext)
     -> ();
    pub fn g_main_context_pop_thread_default(context: *mut GMainContext)
     -> ();
    pub fn g_main_context_get_thread_default() -> *mut GMainContext;
    pub fn g_main_context_ref_thread_default() -> *mut GMainContext;
    pub fn g_main_loop_new(context: *mut GMainContext, is_running: gboolean)
     -> *mut GMainLoop;
    pub fn g_main_loop_run(_loop: *mut GMainLoop) -> ();
    pub fn g_main_loop_quit(_loop: *mut GMainLoop) -> ();
    pub fn g_main_loop_ref(_loop: *mut GMainLoop) -> *mut GMainLoop;
    pub fn g_main_loop_unref(_loop: *mut GMainLoop) -> ();
    pub fn g_main_loop_is_running(_loop: *mut GMainLoop) -> gboolean;
    pub fn g_main_loop_get_context(_loop: *mut GMainLoop)
     -> *mut GMainContext;
    pub fn g_source_new(source_funcs: *mut GSourceFuncs, struct_size: guint)
     -> *mut GSource;
    pub fn g_source_ref(source: *mut GSource) -> *mut GSource;
    pub fn g_source_unref(source: *mut GSource) -> ();
    pub fn g_source_attach(source: *mut GSource, context: *mut GMainContext)
     -> guint;
    pub fn g_source_destroy(source: *mut GSource) -> ();
    pub fn g_source_set_priority(source: *mut GSource, priority: gint) -> ();
    pub fn g_source_get_priority(source: *mut GSource) -> gint;
    pub fn g_source_set_can_recurse(source: *mut GSource,
                                    can_recurse: gboolean) -> ();
    pub fn g_source_get_can_recurse(source: *mut GSource) -> gboolean;
    pub fn g_source_get_id(source: *mut GSource) -> guint;
    pub fn g_source_get_context(source: *mut GSource) -> *mut GMainContext;
    pub fn g_source_set_callback(source: *mut GSource, func: GSourceFunc,
                                 data: gpointer, notify: GDestroyNotify)
     -> ();
    pub fn g_source_set_funcs(source: *mut GSource, funcs: *mut GSourceFuncs)
     -> ();
    pub fn g_source_is_destroyed(source: *mut GSource) -> gboolean;
    pub fn g_source_set_name(source: *mut GSource,
                             name: *const ::libc::c_char) -> ();
    pub fn g_source_get_name(source: *mut GSource) -> *const ::libc::c_char;
    pub fn g_source_set_name_by_id(tag: guint, name: *const ::libc::c_char)
     -> ();
    pub fn g_source_set_ready_time(source: *mut GSource, ready_time: gint64)
     -> ();
    pub fn g_source_get_ready_time(source: *mut GSource) -> gint64;
    pub fn g_source_add_unix_fd(source: *mut GSource, fd: gint,
                                events: GIOCondition) -> gpointer;
    pub fn g_source_modify_unix_fd(source: *mut GSource, tag: gpointer,
                                   new_events: GIOCondition) -> ();
    pub fn g_source_remove_unix_fd(source: *mut GSource, tag: gpointer) -> ();
    pub fn g_source_query_unix_fd(source: *mut GSource, tag: gpointer)
     -> GIOCondition;
    pub fn g_source_set_callback_indirect(source: *mut GSource,
                                          callback_data: gpointer,
                                          callback_funcs:
                                              *mut GSourceCallbackFuncs)
     -> ();
    pub fn g_source_add_poll(source: *mut GSource, fd: *mut GPollFD) -> ();
    pub fn g_source_remove_poll(source: *mut GSource, fd: *mut GPollFD) -> ();
    pub fn g_source_add_child_source(source: *mut GSource,
                                     child_source: *mut GSource) -> ();
    pub fn g_source_remove_child_source(source: *mut GSource,
                                        child_source: *mut GSource) -> ();
    pub fn g_source_get_current_time(source: *mut GSource,
                                     timeval: *mut GTimeVal) -> ();
    pub fn g_source_get_time(source: *mut GSource) -> gint64;
    pub fn g_idle_source_new() -> *mut GSource;
    pub fn g_child_watch_source_new(pid: GPid) -> *mut GSource;
    pub fn g_timeout_source_new(interval: guint) -> *mut GSource;
    pub fn g_timeout_source_new_seconds(interval: guint) -> *mut GSource;
    pub fn g_get_current_time(result: *mut GTimeVal) -> ();
    pub fn g_get_monotonic_time() -> gint64;
    pub fn g_get_real_time() -> gint64;
    pub fn g_source_remove(tag: guint) -> gboolean;
    pub fn g_source_remove_by_user_data(user_data: gpointer) -> gboolean;
    pub fn g_source_remove_by_funcs_user_data(funcs: *mut GSourceFuncs,
                                              user_data: gpointer)
     -> gboolean;
    pub fn g_timeout_add_full(priority: gint, interval: guint,
                              function: GSourceFunc, data: gpointer,
                              notify: GDestroyNotify) -> guint;
    pub fn g_timeout_add(interval: guint, function: GSourceFunc,
                         data: gpointer) -> guint;
    pub fn g_timeout_add_seconds_full(priority: gint, interval: guint,
                                      function: GSourceFunc, data: gpointer,
                                      notify: GDestroyNotify) -> guint;
    pub fn g_timeout_add_seconds(interval: guint, function: GSourceFunc,
                                 data: gpointer) -> guint;
    pub fn g_child_watch_add_full(priority: gint, pid: GPid,
                                  function: GChildWatchFunc, data: gpointer,
                                  notify: GDestroyNotify) -> guint;
    pub fn g_child_watch_add(pid: GPid, function: GChildWatchFunc,
                             data: gpointer) -> guint;
    pub fn g_idle_add(function: GSourceFunc, data: gpointer) -> guint;
    pub fn g_idle_add_full(priority: gint, function: GSourceFunc,
                           data: gpointer, notify: GDestroyNotify) -> guint;
    pub fn g_idle_remove_by_data(data: gpointer) -> gboolean;
    pub fn g_main_context_invoke_full(context: *mut GMainContext,
                                      priority: gint, function: GSourceFunc,
                                      data: gpointer, notify: GDestroyNotify)
     -> ();
    pub fn g_main_context_invoke(context: *mut GMainContext,
                                 function: GSourceFunc, data: gpointer) -> ();
    pub fn g_unicode_script_to_iso15924(script: GUnicodeScript) -> guint32;
    pub fn g_unicode_script_from_iso15924(iso15924: guint32)
     -> GUnicodeScript;
    pub fn g_unichar_isalnum(c: gunichar) -> gboolean;
    pub fn g_unichar_isalpha(c: gunichar) -> gboolean;
    pub fn g_unichar_iscntrl(c: gunichar) -> gboolean;
    pub fn g_unichar_isdigit(c: gunichar) -> gboolean;
    pub fn g_unichar_isgraph(c: gunichar) -> gboolean;
    pub fn g_unichar_islower(c: gunichar) -> gboolean;
    pub fn g_unichar_isprint(c: gunichar) -> gboolean;
    pub fn g_unichar_ispunct(c: gunichar) -> gboolean;
    pub fn g_unichar_isspace(c: gunichar) -> gboolean;
    pub fn g_unichar_isupper(c: gunichar) -> gboolean;
    pub fn g_unichar_isxdigit(c: gunichar) -> gboolean;
    pub fn g_unichar_istitle(c: gunichar) -> gboolean;
    pub fn g_unichar_isdefined(c: gunichar) -> gboolean;
    pub fn g_unichar_iswide(c: gunichar) -> gboolean;
    pub fn g_unichar_iswide_cjk(c: gunichar) -> gboolean;
    pub fn g_unichar_iszerowidth(c: gunichar) -> gboolean;
    pub fn g_unichar_ismark(c: gunichar) -> gboolean;
    pub fn g_unichar_toupper(c: gunichar) -> gunichar;
    pub fn g_unichar_tolower(c: gunichar) -> gunichar;
    pub fn g_unichar_totitle(c: gunichar) -> gunichar;
    pub fn g_unichar_digit_value(c: gunichar) -> gint;
    pub fn g_unichar_xdigit_value(c: gunichar) -> gint;
    pub fn g_unichar_type(c: gunichar) -> GUnicodeType;
    pub fn g_unichar_break_type(c: gunichar) -> GUnicodeBreakType;
    pub fn g_unichar_combining_class(uc: gunichar) -> gint;
    pub fn g_unichar_get_mirror_char(ch: gunichar, mirrored_ch: *mut gunichar)
     -> gboolean;
    pub fn g_unichar_get_script(ch: gunichar) -> GUnicodeScript;
    pub fn g_unichar_validate(ch: gunichar) -> gboolean;
    pub fn g_unichar_compose(a: gunichar, b: gunichar, ch: *mut gunichar)
     -> gboolean;
    pub fn g_unichar_decompose(ch: gunichar, a: *mut gunichar,
                               b: *mut gunichar) -> gboolean;
    pub fn g_unichar_fully_decompose(ch: gunichar, compat: gboolean,
                                     result: *mut gunichar, result_len: gsize)
     -> gsize;
    pub fn g_unicode_canonical_ordering(string: *mut gunichar, len: gsize)
     -> ();
    pub fn g_unicode_canonical_decomposition(ch: gunichar,
                                             result_len: *mut gsize)
     -> *mut gunichar;
    pub fn g_utf8_get_char(p: *const gchar) -> gunichar;
    pub fn g_utf8_get_char_validated(p: *const gchar, max_len: gssize)
     -> gunichar;
    pub fn g_utf8_offset_to_pointer(str: *const gchar, offset: glong)
     -> *mut gchar;
    pub fn g_utf8_pointer_to_offset(str: *const gchar, pos: *const gchar)
     -> glong;
    pub fn g_utf8_prev_char(p: *const gchar) -> *mut gchar;
    pub fn g_utf8_find_next_char(p: *const gchar, end: *const gchar)
     -> *mut gchar;
    pub fn g_utf8_find_prev_char(str: *const gchar, p: *const gchar)
     -> *mut gchar;
    pub fn g_utf8_strlen(p: *const gchar, max: gssize) -> glong;
    pub fn g_utf8_substring(str: *const gchar, start_pos: glong,
                            end_pos: glong) -> *mut gchar;
    pub fn g_utf8_strncpy(dest: *mut gchar, src: *const gchar, n: gsize)
     -> *mut gchar;
    pub fn g_utf8_strchr(p: *const gchar, len: gssize, c: gunichar)
     -> *mut gchar;
    pub fn g_utf8_strrchr(p: *const gchar, len: gssize, c: gunichar)
     -> *mut gchar;
    pub fn g_utf8_strreverse(str: *const gchar, len: gssize) -> *mut gchar;
    pub fn g_utf8_to_utf16(str: *const gchar, len: glong,
                           items_read: *mut glong, items_written: *mut glong,
                           error: *mut *mut GError) -> *mut gunichar2;
    pub fn g_utf8_to_ucs4(str: *const gchar, len: glong,
                          items_read: *mut glong, items_written: *mut glong,
                          error: *mut *mut GError) -> *mut gunichar;
    pub fn g_utf8_to_ucs4_fast(str: *const gchar, len: glong,
                               items_written: *mut glong) -> *mut gunichar;
    pub fn g_utf16_to_ucs4(str: *const gunichar2, len: glong,
                           items_read: *mut glong, items_written: *mut glong,
                           error: *mut *mut GError) -> *mut gunichar;
    pub fn g_utf16_to_utf8(str: *const gunichar2, len: glong,
                           items_read: *mut glong, items_written: *mut glong,
                           error: *mut *mut GError) -> *mut gchar;
    pub fn g_ucs4_to_utf16(str: *const gunichar, len: glong,
                           items_read: *mut glong, items_written: *mut glong,
                           error: *mut *mut GError) -> *mut gunichar2;
    pub fn g_ucs4_to_utf8(str: *const gunichar, len: glong,
                          items_read: *mut glong, items_written: *mut glong,
                          error: *mut *mut GError) -> *mut gchar;
    pub fn g_unichar_to_utf8(c: gunichar, outbuf: *mut gchar) -> gint;
    pub fn g_utf8_validate(str: *const gchar, max_len: gssize,
                           end: *mut *const gchar) -> gboolean;
    pub fn g_utf8_strup(str: *const gchar, len: gssize) -> *mut gchar;
    pub fn g_utf8_strdown(str: *const gchar, len: gssize) -> *mut gchar;
    pub fn g_utf8_casefold(str: *const gchar, len: gssize) -> *mut gchar;
    pub fn g_utf8_normalize(str: *const gchar, len: gssize,
                            mode: GNormalizeMode) -> *mut gchar;
    pub fn g_utf8_collate(str1: *const gchar, str2: *const gchar) -> gint;
    pub fn g_utf8_collate_key(str: *const gchar, len: gssize) -> *mut gchar;
    pub fn g_utf8_collate_key_for_filename(str: *const gchar, len: gssize)
     -> *mut gchar;
    pub fn _g_utf8_make_valid(name: *const gchar) -> *mut gchar;
    pub fn g_get_user_name() -> *const gchar;
    pub fn g_get_real_name() -> *const gchar;
    pub fn g_get_home_dir() -> *const gchar;
    pub fn g_get_tmp_dir() -> *const gchar;
    pub fn g_get_host_name() -> *const gchar;
    pub fn g_get_prgname() -> *const gchar;
    pub fn g_set_prgname(prgname: *const gchar) -> ();
    pub fn g_get_application_name() -> *const gchar;
    pub fn g_set_application_name(application_name: *const gchar) -> ();
    pub fn g_reload_user_special_dirs_cache() -> ();
    pub fn g_get_user_data_dir() -> *const gchar;
    pub fn g_get_user_config_dir() -> *const gchar;
    pub fn g_get_user_cache_dir() -> *const gchar;
    pub fn g_get_system_data_dirs() -> *const *const gchar;
    pub fn g_get_system_config_dirs() -> *const *const gchar;
    pub fn g_get_user_runtime_dir() -> *const gchar;
    pub fn g_get_user_special_dir(directory: GUserDirectory) -> *const gchar;
    pub fn g_parse_debug_string(string: *const gchar, keys: *const GDebugKey,
                                nkeys: guint) -> guint;
    pub fn g_snprintf(string: *mut gchar, n: gulong,
                      format: *const gchar, ...) -> gint;
    pub fn g_vsnprintf(string: *mut gchar, n: gulong, format: *const gchar,
                       args: va_list) -> gint;
    pub fn g_nullify_pointer(nullify_location: *mut gpointer) -> ();
    pub fn g_format_size_full(size: guint64, flags: GFormatSizeFlags)
     -> *mut gchar;
    pub fn g_format_size(size: guint64) -> *mut gchar;
    pub fn g_format_size_for_display(size: goffset) -> *mut gchar;
    pub fn g_atexit(func: GVoidFunc) -> ();
    pub fn g_find_program_in_path(program: *const gchar) -> *mut gchar;
    pub fn g_string_new(init: *const gchar) -> *mut GString;
    pub fn g_string_new_len(init: *const gchar, len: gssize) -> *mut GString;
    pub fn g_string_sized_new(dfl_size: gsize) -> *mut GString;
    pub fn g_string_free(string: *mut GString, free_segment: gboolean)
     -> *mut gchar;
    pub fn g_string_free_to_bytes(string: *mut GString) -> *mut GBytes;
    pub fn g_string_equal(v: *const GString, v2: *const GString) -> gboolean;
    pub fn g_string_hash(str: *const GString) -> guint;
    pub fn g_string_assign(string: *mut GString, rval: *const gchar)
     -> *mut GString;
    pub fn g_string_truncate(string: *mut GString, len: gsize)
     -> *mut GString;
    pub fn g_string_set_size(string: *mut GString, len: gsize)
     -> *mut GString;
    pub fn g_string_insert_len(string: *mut GString, pos: gssize,
                               val: *const gchar, len: gssize)
     -> *mut GString;
    pub fn g_string_append(string: *mut GString, val: *const gchar)
     -> *mut GString;
    pub fn g_string_append_len(string: *mut GString, val: *const gchar,
                               len: gssize) -> *mut GString;
    pub fn g_string_append_c(string: *mut GString, c: gchar) -> *mut GString;
    pub fn g_string_append_unichar(string: *mut GString, wc: gunichar)
     -> *mut GString;
    pub fn g_string_prepend(string: *mut GString, val: *const gchar)
     -> *mut GString;
    pub fn g_string_prepend_c(string: *mut GString, c: gchar) -> *mut GString;
    pub fn g_string_prepend_unichar(string: *mut GString, wc: gunichar)
     -> *mut GString;
    pub fn g_string_prepend_len(string: *mut GString, val: *const gchar,
                                len: gssize) -> *mut GString;
    pub fn g_string_insert(string: *mut GString, pos: gssize,
                           val: *const gchar) -> *mut GString;
    pub fn g_string_insert_c(string: *mut GString, pos: gssize, c: gchar)
     -> *mut GString;
    pub fn g_string_insert_unichar(string: *mut GString, pos: gssize,
                                   wc: gunichar) -> *mut GString;
    pub fn g_string_overwrite(string: *mut GString, pos: gsize,
                              val: *const gchar) -> *mut GString;
    pub fn g_string_overwrite_len(string: *mut GString, pos: gsize,
                                  val: *const gchar, len: gssize)
     -> *mut GString;
    pub fn g_string_erase(string: *mut GString, pos: gssize, len: gssize)
     -> *mut GString;
    pub fn g_string_ascii_down(string: *mut GString) -> *mut GString;
    pub fn g_string_ascii_up(string: *mut GString) -> *mut GString;
    pub fn g_string_vprintf(string: *mut GString, format: *const gchar,
                            args: va_list) -> ();
    pub fn g_string_printf(string: *mut GString, format: *const gchar, ...)
     -> ();
    pub fn g_string_append_vprintf(string: *mut GString, format: *const gchar,
                                   args: va_list) -> ();
    pub fn g_string_append_printf(string: *mut GString,
                                  format: *const gchar, ...) -> ();
    pub fn g_string_append_uri_escaped(string: *mut GString,
                                       unescaped: *const gchar,
                                       reserved_chars_allowed: *const gchar,
                                       allow_utf8: gboolean) -> *mut GString;
    pub fn g_string_down(string: *mut GString) -> *mut GString;
    pub fn g_string_up(string: *mut GString) -> *mut GString;
    pub fn g_io_channel_init(channel: *mut GIOChannel) -> ();
    pub fn g_io_channel_ref(channel: *mut GIOChannel) -> *mut GIOChannel;
    pub fn g_io_channel_unref(channel: *mut GIOChannel) -> ();
    pub fn g_io_channel_read(channel: *mut GIOChannel, buf: *mut gchar,
                             count: gsize, bytes_read: *mut gsize)
     -> GIOError;
    pub fn g_io_channel_write(channel: *mut GIOChannel, buf: *const gchar,
                              count: gsize, bytes_written: *mut gsize)
     -> GIOError;
    pub fn g_io_channel_seek(channel: *mut GIOChannel, offset: gint64,
                             _type: GSeekType) -> GIOError;
    pub fn g_io_channel_close(channel: *mut GIOChannel) -> ();
    pub fn g_io_channel_shutdown(channel: *mut GIOChannel, flush: gboolean,
                                 err: *mut *mut GError) -> GIOStatus;
    pub fn g_io_add_watch_full(channel: *mut GIOChannel, priority: gint,
                               condition: GIOCondition, func: GIOFunc,
                               user_data: gpointer, notify: GDestroyNotify)
     -> guint;
    pub fn g_io_create_watch(channel: *mut GIOChannel,
                             condition: GIOCondition) -> *mut GSource;
    pub fn g_io_add_watch(channel: *mut GIOChannel, condition: GIOCondition,
                          func: GIOFunc, user_data: gpointer) -> guint;
    pub fn g_io_channel_set_buffer_size(channel: *mut GIOChannel, size: gsize)
     -> ();
    pub fn g_io_channel_get_buffer_size(channel: *mut GIOChannel) -> gsize;
    pub fn g_io_channel_get_buffer_condition(channel: *mut GIOChannel)
     -> GIOCondition;
    pub fn g_io_channel_set_flags(channel: *mut GIOChannel, flags: GIOFlags,
                                  error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_get_flags(channel: *mut GIOChannel) -> GIOFlags;
    pub fn g_io_channel_set_line_term(channel: *mut GIOChannel,
                                      line_term: *const gchar, length: gint)
     -> ();
    pub fn g_io_channel_get_line_term(channel: *mut GIOChannel,
                                      length: *mut gint) -> *const gchar;
    pub fn g_io_channel_set_buffered(channel: *mut GIOChannel,
                                     buffered: gboolean) -> ();
    pub fn g_io_channel_get_buffered(channel: *mut GIOChannel) -> gboolean;
    pub fn g_io_channel_set_encoding(channel: *mut GIOChannel,
                                     encoding: *const gchar,
                                     error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_get_encoding(channel: *mut GIOChannel)
     -> *const gchar;
    pub fn g_io_channel_set_close_on_unref(channel: *mut GIOChannel,
                                           do_close: gboolean) -> ();
    pub fn g_io_channel_get_close_on_unref(channel: *mut GIOChannel)
     -> gboolean;
    pub fn g_io_channel_flush(channel: *mut GIOChannel,
                              error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_read_line(channel: *mut GIOChannel,
                                  str_return: *mut *mut gchar,
                                  length: *mut gsize,
                                  terminator_pos: *mut gsize,
                                  error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_read_line_string(channel: *mut GIOChannel,
                                         buffer: *mut GString,
                                         terminator_pos: *mut gsize,
                                         error: *mut *mut GError)
     -> GIOStatus;
    pub fn g_io_channel_read_to_end(channel: *mut GIOChannel,
                                    str_return: *mut *mut gchar,
                                    length: *mut gsize,
                                    error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_read_chars(channel: *mut GIOChannel, buf: *mut gchar,
                                   count: gsize, bytes_read: *mut gsize,
                                   error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_read_unichar(channel: *mut GIOChannel,
                                     thechar: *mut gunichar,
                                     error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_write_chars(channel: *mut GIOChannel,
                                    buf: *const gchar, count: gssize,
                                    bytes_written: *mut gsize,
                                    error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_write_unichar(channel: *mut GIOChannel,
                                      thechar: gunichar,
                                      error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_seek_position(channel: *mut GIOChannel,
                                      offset: gint64, _type: GSeekType,
                                      error: *mut *mut GError) -> GIOStatus;
    pub fn g_io_channel_new_file(filename: *const gchar, mode: *const gchar,
                                 error: *mut *mut GError) -> *mut GIOChannel;
    pub fn g_io_channel_error_quark() -> GQuark;
    pub fn g_io_channel_error_from_errno(en: gint) -> GIOChannelError;
    pub fn g_io_channel_unix_new(fd: ::libc::c_int) -> *mut GIOChannel;
    pub fn g_io_channel_unix_get_fd(channel: *mut GIOChannel) -> gint;
    pub fn g_key_file_error_quark() -> GQuark;
    pub fn g_key_file_new() -> *mut GKeyFile;
    pub fn g_key_file_ref(key_file: *mut GKeyFile) -> *mut GKeyFile;
    pub fn g_key_file_unref(key_file: *mut GKeyFile) -> ();
    pub fn g_key_file_free(key_file: *mut GKeyFile) -> ();
    pub fn g_key_file_set_list_separator(key_file: *mut GKeyFile,
                                         separator: gchar) -> ();
    pub fn g_key_file_load_from_file(key_file: *mut GKeyFile,
                                     file: *const gchar, flags: GKeyFileFlags,
                                     error: *mut *mut GError) -> gboolean;
    pub fn g_key_file_load_from_data(key_file: *mut GKeyFile,
                                     data: *const gchar, length: gsize,
                                     flags: GKeyFileFlags,
                                     error: *mut *mut GError) -> gboolean;
    pub fn g_key_file_load_from_dirs(key_file: *mut GKeyFile,
                                     file: *const gchar,
                                     search_dirs: *mut *const gchar,
                                     full_path: *mut *mut gchar,
                                     flags: GKeyFileFlags,
                                     error: *mut *mut GError) -> gboolean;
    pub fn g_key_file_load_from_data_dirs(key_file: *mut GKeyFile,
                                          file: *const gchar,
                                          full_path: *mut *mut gchar,
                                          flags: GKeyFileFlags,
                                          error: *mut *mut GError)
     -> gboolean;
    pub fn g_key_file_to_data(key_file: *mut GKeyFile, length: *mut gsize,
                              error: *mut *mut GError) -> *mut gchar;
    pub fn g_key_file_save_to_file(key_file: *mut GKeyFile,
                                   filename: *const gchar,
                                   error: *mut *mut GError) -> gboolean;
    pub fn g_key_file_get_start_group(key_file: *mut GKeyFile) -> *mut gchar;
    pub fn g_key_file_get_groups(key_file: *mut GKeyFile, length: *mut gsize)
     -> *mut *mut gchar;
    pub fn g_key_file_get_keys(key_file: *mut GKeyFile,
                               group_name: *const gchar, length: *mut gsize,
                               error: *mut *mut GError) -> *mut *mut gchar;
    pub fn g_key_file_has_group(key_file: *mut GKeyFile,
                                group_name: *const gchar) -> gboolean;
    pub fn g_key_file_has_key(key_file: *mut GKeyFile,
                              group_name: *const gchar, key: *const gchar,
                              error: *mut *mut GError) -> gboolean;
    pub fn g_key_file_get_value(key_file: *mut GKeyFile,
                                group_name: *const gchar, key: *const gchar,
                                error: *mut *mut GError) -> *mut gchar;
    pub fn g_key_file_set_value(key_file: *mut GKeyFile,
                                group_name: *const gchar, key: *const gchar,
                                value: *const gchar) -> ();
    pub fn g_key_file_get_string(key_file: *mut GKeyFile,
                                 group_name: *const gchar, key: *const gchar,
                                 error: *mut *mut GError) -> *mut gchar;
    pub fn g_key_file_set_string(key_file: *mut GKeyFile,
                                 group_name: *const gchar, key: *const gchar,
                                 string: *const gchar) -> ();
    pub fn g_key_file_get_locale_string(key_file: *mut GKeyFile,
                                        group_name: *const gchar,
                                        key: *const gchar,
                                        locale: *const gchar,
                                        error: *mut *mut GError)
     -> *mut gchar;
    pub fn g_key_file_set_locale_string(key_file: *mut GKeyFile,
                                        group_name: *const gchar,
                                        key: *const gchar,
                                        locale: *const gchar,
                                        string: *const gchar) -> ();
    pub fn g_key_file_get_boolean(key_file: *mut GKeyFile,
                                  group_name: *const gchar, key: *const gchar,
                                  error: *mut *mut GError) -> gboolean;
    pub fn g_key_file_set_boolean(key_file: *mut GKeyFile,
                                  group_name: *const gchar, key: *const gchar,
                                  value: gboolean) -> ();
    pub fn g_key_file_get_integer(key_file: *mut GKeyFile,
                                  group_name: *const gchar, key: *const gchar,
                                  error: *mut *mut GError) -> gint;
    pub fn g_key_file_set_integer(key_file: *mut GKeyFile,
                                  group_name: *const gchar, key: *const gchar,
                                  value: gint) -> ();
    pub fn g_key_file_get_int64(key_file: *mut GKeyFile,
                                group_name: *const gchar, key: *const gchar,
                                error: *mut *mut GError) -> gint64;
    pub fn g_key_file_set_int64(key_file: *mut GKeyFile,
                                group_name: *const gchar, key: *const gchar,
                                value: gint64) -> ();
    pub fn g_key_file_get_uint64(key_file: *mut GKeyFile,
                                 group_name: *const gchar, key: *const gchar,
                                 error: *mut *mut GError) -> guint64;
    pub fn g_key_file_set_uint64(key_file: *mut GKeyFile,
                                 group_name: *const gchar, key: *const gchar,
                                 value: guint64) -> ();
    pub fn g_key_file_get_double(key_file: *mut GKeyFile,
                                 group_name: *const gchar, key: *const gchar,
                                 error: *mut *mut GError) -> gdouble;
    pub fn g_key_file_set_double(key_file: *mut GKeyFile,
                                 group_name: *const gchar, key: *const gchar,
                                 value: gdouble) -> ();
    pub fn g_key_file_get_string_list(key_file: *mut GKeyFile,
                                      group_name: *const gchar,
                                      key: *const gchar, length: *mut gsize,
                                      error: *mut *mut GError)
     -> *mut *mut gchar;
    pub fn g_key_file_set_string_list(key_file: *mut GKeyFile,
                                      group_name: *const gchar,
                                      key: *const gchar,
                                      list: *const *const gchar,
                                      length: gsize) -> ();
    pub fn g_key_file_get_locale_string_list(key_file: *mut GKeyFile,
                                             group_name: *const gchar,
                                             key: *const gchar,
                                             locale: *const gchar,
                                             length: *mut gsize,
                                             error: *mut *mut GError)
     -> *mut *mut gchar;
    pub fn g_key_file_set_locale_string_list(key_file: *mut GKeyFile,
                                             group_name: *const gchar,
                                             key: *const gchar,
                                             locale: *const gchar,
                                             list: *const *const gchar,
                                             length: gsize) -> ();
    pub fn g_key_file_get_boolean_list(key_file: *mut GKeyFile,
                                       group_name: *const gchar,
                                       key: *const gchar, length: *mut gsize,
                                       error: *mut *mut GError)
     -> *mut gboolean;
    pub fn g_key_file_set_boolean_list(key_file: *mut GKeyFile,
                                       group_name: *const gchar,
                                       key: *const gchar, list: *mut gboolean,
                                       length: gsize) -> ();
    pub fn g_key_file_get_integer_list(key_file: *mut GKeyFile,
                                       group_name: *const gchar,
                                       key: *const gchar, length: *mut gsize,
                                       error: *mut *mut GError) -> *mut gint;
    pub fn g_key_file_set_double_list(key_file: *mut GKeyFile,
                                      group_name: *const gchar,
                                      key: *const gchar, list: *mut gdouble,
                                      length: gsize) -> ();
    pub fn g_key_file_get_double_list(key_file: *mut GKeyFile,
                                      group_name: *const gchar,
                                      key: *const gchar, length: *mut gsize,
                                      error: *mut *mut GError)
     -> *mut gdouble;
    pub fn g_key_file_set_integer_list(key_file: *mut GKeyFile,
                                       group_name: *const gchar,
                                       key: *const gchar, list: *mut gint,
                                       length: gsize) -> ();
    pub fn g_key_file_set_comment(key_file: *mut GKeyFile,
                                  group_name: *const gchar, key: *const gchar,
                                  comment: *const gchar,
                                  error: *mut *mut GError) -> gboolean;
    pub fn g_key_file_get_comment(key_file: *mut GKeyFile,
                                  group_name: *const gchar, key: *const gchar,
                                  error: *mut *mut GError) -> *mut gchar;
    pub fn g_key_file_remove_comment(key_file: *mut GKeyFile,
                                     group_name: *const gchar,
                                     key: *const gchar,
                                     error: *mut *mut GError) -> gboolean;
    pub fn g_key_file_remove_key(key_file: *mut GKeyFile,
                                 group_name: *const gchar, key: *const gchar,
                                 error: *mut *mut GError) -> gboolean;
    pub fn g_key_file_remove_group(key_file: *mut GKeyFile,
                                   group_name: *const gchar,
                                   error: *mut *mut GError) -> gboolean;
    pub fn g_mapped_file_new(filename: *const gchar, writable: gboolean,
                             error: *mut *mut GError) -> *mut GMappedFile;
    pub fn g_mapped_file_new_from_fd(fd: gint, writable: gboolean,
                                     error: *mut *mut GError)
     -> *mut GMappedFile;
    pub fn g_mapped_file_get_length(file: *mut GMappedFile) -> gsize;
    pub fn g_mapped_file_get_contents(file: *mut GMappedFile) -> *mut gchar;
    pub fn g_mapped_file_get_bytes(file: *mut GMappedFile) -> *mut GBytes;
    pub fn g_mapped_file_ref(file: *mut GMappedFile) -> *mut GMappedFile;
    pub fn g_mapped_file_unref(file: *mut GMappedFile) -> ();
    pub fn g_mapped_file_free(file: *mut GMappedFile) -> ();
    pub fn g_markup_error_quark() -> GQuark;
    pub fn g_markup_parse_context_new(parser: *const GMarkupParser,
                                      flags: GMarkupParseFlags,
                                      user_data: gpointer,
                                      user_data_dnotify: GDestroyNotify)
     -> *mut GMarkupParseContext;
    pub fn g_markup_parse_context_ref(context: *mut GMarkupParseContext)
     -> *mut GMarkupParseContext;
    pub fn g_markup_parse_context_unref(context: *mut GMarkupParseContext)
     -> ();
    pub fn g_markup_parse_context_free(context: *mut GMarkupParseContext)
     -> ();
    pub fn g_markup_parse_context_parse(context: *mut GMarkupParseContext,
                                        text: *const gchar, text_len: gssize,
                                        error: *mut *mut GError) -> gboolean;
    pub fn g_markup_parse_context_push(context: *mut GMarkupParseContext,
                                       parser: *const GMarkupParser,
                                       user_data: gpointer) -> ();
    pub fn g_markup_parse_context_pop(context: *mut GMarkupParseContext)
     -> gpointer;
    pub fn g_markup_parse_context_end_parse(context: *mut GMarkupParseContext,
                                            error: *mut *mut GError)
     -> gboolean;
    pub fn g_markup_parse_context_get_element(context:
                                                  *mut GMarkupParseContext)
     -> *const gchar;
    pub fn g_markup_parse_context_get_element_stack(context:
                                                        *mut GMarkupParseContext)
     -> *const GSList;
    pub fn g_markup_parse_context_get_position(context:
                                                   *mut GMarkupParseContext,
                                               line_number: *mut gint,
                                               char_number: *mut gint) -> ();
    pub fn g_markup_parse_context_get_user_data(context:
                                                    *mut GMarkupParseContext)
     -> gpointer;
    pub fn g_markup_escape_text(text: *const gchar, length: gssize)
     -> *mut gchar;
    pub fn g_markup_printf_escaped(format: *const ::libc::c_char, ...)
     -> *mut gchar;
    pub fn g_markup_vprintf_escaped(format: *const ::libc::c_char,
                                    args: va_list) -> *mut gchar;
    pub fn g_markup_collect_attributes(element_name: *const gchar,
                                       attribute_names: *mut *const gchar,
                                       attribute_values: *mut *const gchar,
                                       error: *mut *mut GError,
                                       first_type: GMarkupCollectType,
                                       first_attr: *const gchar, ...)
     -> gboolean;
    pub fn g_printf_string_upper_bound(format: *const gchar, args: va_list)
     -> gsize;
    pub fn g_log_set_handler(log_domain: *const gchar,
                             log_levels: GLogLevelFlags, log_func: GLogFunc,
                             user_data: gpointer) -> guint;
    pub fn g_log_remove_handler(log_domain: *const gchar, handler_id: guint)
     -> ();
    pub fn g_log_default_handler(log_domain: *const gchar,
                                 log_level: GLogLevelFlags,
                                 message: *const gchar, unused_data: gpointer)
     -> ();
    pub fn g_log_set_default_handler(log_func: GLogFunc, user_data: gpointer)
     -> GLogFunc;
    pub fn g_log(log_domain: *const gchar, log_level: GLogLevelFlags,
                 format: *const gchar, ...) -> ();
    pub fn g_logv(log_domain: *const gchar, log_level: GLogLevelFlags,
                  format: *const gchar, args: va_list) -> ();
    pub fn g_log_set_fatal_mask(log_domain: *const gchar,
                                fatal_mask: GLogLevelFlags) -> GLogLevelFlags;
    pub fn g_log_set_always_fatal(fatal_mask: GLogLevelFlags)
     -> GLogLevelFlags;
    pub fn _g_log_fallback_handler(log_domain: *const gchar,
                                   log_level: GLogLevelFlags,
                                   message: *const gchar,
                                   unused_data: gpointer) -> ();
    pub fn g_return_if_fail_warning(log_domain: *const ::libc::c_char,
                                    pretty_function: *const ::libc::c_char,
                                    expression: *const ::libc::c_char) -> ();
    pub fn g_warn_message(domain: *const ::libc::c_char,
                          file: *const ::libc::c_char, line: ::libc::c_int,
                          func: *const ::libc::c_char,
                          warnexpr: *const ::libc::c_char) -> ();
    pub fn g_assert_warning(log_domain: *const ::libc::c_char,
                            file: *const ::libc::c_char, line: ::libc::c_int,
                            pretty_function: *const ::libc::c_char,
                            expression: *const ::libc::c_char) -> ();
    pub fn g_print(format: *const gchar, ...) -> ();
    pub fn g_set_print_handler(func: GPrintFunc) -> GPrintFunc;
    pub fn g_printerr(format: *const gchar, ...) -> ();
    pub fn g_set_printerr_handler(func: GPrintFunc) -> GPrintFunc;
    pub fn g_option_error_quark() -> GQuark;
    pub fn g_option_context_new(parameter_string: *const gchar)
     -> *mut GOptionContext;
    pub fn g_option_context_set_summary(context: *mut GOptionContext,
                                        summary: *const gchar) -> ();
    pub fn g_option_context_get_summary(context: *mut GOptionContext)
     -> *const gchar;
    pub fn g_option_context_set_description(context: *mut GOptionContext,
                                            description: *const gchar) -> ();
    pub fn g_option_context_get_description(context: *mut GOptionContext)
     -> *const gchar;
    pub fn g_option_context_free(context: *mut GOptionContext) -> ();
    pub fn g_option_context_set_help_enabled(context: *mut GOptionContext,
                                             help_enabled: gboolean) -> ();
    pub fn g_option_context_get_help_enabled(context: *mut GOptionContext)
     -> gboolean;
    pub fn g_option_context_set_ignore_unknown_options(context:
                                                           *mut GOptionContext,
                                                       ignore_unknown:
                                                           gboolean) -> ();
    pub fn g_option_context_get_ignore_unknown_options(context:
                                                           *mut GOptionContext)
     -> gboolean;
    pub fn g_option_context_add_main_entries(context: *mut GOptionContext,
                                             entries: *const GOptionEntry,
                                             translation_domain: *const gchar)
     -> ();
    pub fn g_option_context_parse(context: *mut GOptionContext,
                                  argc: *mut gint, argv: *mut *mut *mut gchar,
                                  error: *mut *mut GError) -> gboolean;
    pub fn g_option_context_parse_strv(context: *mut GOptionContext,
                                       arguments: *mut *mut *mut gchar,
                                       error: *mut *mut GError) -> gboolean;
    pub fn g_option_context_set_translate_func(context: *mut GOptionContext,
                                               func: GTranslateFunc,
                                               data: gpointer,
                                               destroy_notify: GDestroyNotify)
     -> ();
    pub fn g_option_context_set_translation_domain(context:
                                                       *mut GOptionContext,
                                                   domain: *const gchar)
     -> ();
    pub fn g_option_context_add_group(context: *mut GOptionContext,
                                      group: *mut GOptionGroup) -> ();
    pub fn g_option_context_set_main_group(context: *mut GOptionContext,
                                           group: *mut GOptionGroup) -> ();
    pub fn g_option_context_get_main_group(context: *mut GOptionContext)
     -> *mut GOptionGroup;
    pub fn g_option_context_get_help(context: *mut GOptionContext,
                                     main_help: gboolean,
                                     group: *mut GOptionGroup) -> *mut gchar;
    pub fn g_option_group_new(name: *const gchar, description: *const gchar,
                              help_description: *const gchar,
                              user_data: gpointer, destroy: GDestroyNotify)
     -> *mut GOptionGroup;
    pub fn g_option_group_set_parse_hooks(group: *mut GOptionGroup,
                                          pre_parse_func: GOptionParseFunc,
                                          post_parse_func: GOptionParseFunc)
     -> ();
    pub fn g_option_group_set_error_hook(group: *mut GOptionGroup,
                                         error_func: GOptionErrorFunc) -> ();
    pub fn g_option_group_free(group: *mut GOptionGroup) -> ();
    pub fn g_option_group_add_entries(group: *mut GOptionGroup,
                                      entries: *const GOptionEntry) -> ();
    pub fn g_option_group_set_translate_func(group: *mut GOptionGroup,
                                             func: GTranslateFunc,
                                             data: gpointer,
                                             destroy_notify: GDestroyNotify)
     -> ();
    pub fn g_option_group_set_translation_domain(group: *mut GOptionGroup,
                                                 domain: *const gchar) -> ();
    pub fn g_pattern_spec_new(pattern: *const gchar) -> *mut GPatternSpec;
    pub fn g_pattern_spec_free(pspec: *mut GPatternSpec) -> ();
    pub fn g_pattern_spec_equal(pspec1: *mut GPatternSpec,
                                pspec2: *mut GPatternSpec) -> gboolean;
    pub fn g_pattern_match(pspec: *mut GPatternSpec, string_length: guint,
                           string: *const gchar,
                           string_reversed: *const gchar) -> gboolean;
    pub fn g_pattern_match_string(pspec: *mut GPatternSpec,
                                  string: *const gchar) -> gboolean;
    pub fn g_pattern_match_simple(pattern: *const gchar, string: *const gchar)
     -> gboolean;
    pub fn g_spaced_primes_closest(num: guint) -> guint;
    pub fn g_qsort_with_data(pbase: gconstpointer, total_elems: gint,
                             size: gsize, compare_func: GCompareDataFunc,
                             user_data: gpointer) -> ();
    pub fn g_queue_new() -> *mut GQueue;
    pub fn g_queue_free(queue: *mut GQueue) -> ();
    pub fn g_queue_free_full(queue: *mut GQueue, free_func: GDestroyNotify)
     -> ();
    pub fn g_queue_init(queue: *mut GQueue) -> ();
    pub fn g_queue_clear(queue: *mut GQueue) -> ();
    pub fn g_queue_is_empty(queue: *mut GQueue) -> gboolean;
    pub fn g_queue_get_length(queue: *mut GQueue) -> guint;
    pub fn g_queue_reverse(queue: *mut GQueue) -> ();
    pub fn g_queue_copy(queue: *mut GQueue) -> *mut GQueue;
    pub fn g_queue_foreach(queue: *mut GQueue, func: GFunc,
                           user_data: gpointer) -> ();
    pub fn g_queue_find(queue: *mut GQueue, data: gconstpointer)
     -> *mut GList;
    pub fn g_queue_find_custom(queue: *mut GQueue, data: gconstpointer,
                               func: GCompareFunc) -> *mut GList;
    pub fn g_queue_sort(queue: *mut GQueue, compare_func: GCompareDataFunc,
                        user_data: gpointer) -> ();
    pub fn g_queue_push_head(queue: *mut GQueue, data: gpointer) -> ();
    pub fn g_queue_push_tail(queue: *mut GQueue, data: gpointer) -> ();
    pub fn g_queue_push_nth(queue: *mut GQueue, data: gpointer, n: gint)
     -> ();
    pub fn g_queue_pop_head(queue: *mut GQueue) -> gpointer;
    pub fn g_queue_pop_tail(queue: *mut GQueue) -> gpointer;
    pub fn g_queue_pop_nth(queue: *mut GQueue, n: guint) -> gpointer;
    pub fn g_queue_peek_head(queue: *mut GQueue) -> gpointer;
    pub fn g_queue_peek_tail(queue: *mut GQueue) -> gpointer;
    pub fn g_queue_peek_nth(queue: *mut GQueue, n: guint) -> gpointer;
    pub fn g_queue_index(queue: *mut GQueue, data: gconstpointer) -> gint;
    pub fn g_queue_remove(queue: *mut GQueue, data: gconstpointer)
     -> gboolean;
    pub fn g_queue_remove_all(queue: *mut GQueue, data: gconstpointer)
     -> guint;
    pub fn g_queue_insert_before(queue: *mut GQueue, sibling: *mut GList,
                                 data: gpointer) -> ();
    pub fn g_queue_insert_after(queue: *mut GQueue, sibling: *mut GList,
                                data: gpointer) -> ();
    pub fn g_queue_insert_sorted(queue: *mut GQueue, data: gpointer,
                                 func: GCompareDataFunc, user_data: gpointer)
     -> ();
    pub fn g_queue_push_head_link(queue: *mut GQueue, link_: *mut GList)
     -> ();
    pub fn g_queue_push_tail_link(queue: *mut GQueue, link_: *mut GList)
     -> ();
    pub fn g_queue_push_nth_link(queue: *mut GQueue, n: gint,
                                 link_: *mut GList) -> ();
    pub fn g_queue_pop_head_link(queue: *mut GQueue) -> *mut GList;
    pub fn g_queue_pop_tail_link(queue: *mut GQueue) -> *mut GList;
    pub fn g_queue_pop_nth_link(queue: *mut GQueue, n: guint) -> *mut GList;
    pub fn g_queue_peek_head_link(queue: *mut GQueue) -> *mut GList;
    pub fn g_queue_peek_tail_link(queue: *mut GQueue) -> *mut GList;
    pub fn g_queue_peek_nth_link(queue: *mut GQueue, n: guint) -> *mut GList;
    pub fn g_queue_link_index(queue: *mut GQueue, link_: *mut GList) -> gint;
    pub fn g_queue_unlink(queue: *mut GQueue, link_: *mut GList) -> ();
    pub fn g_queue_delete_link(queue: *mut GQueue, link_: *mut GList) -> ();
    pub fn g_rand_new_with_seed(seed: guint32) -> *mut GRand;
    pub fn g_rand_new_with_seed_array(seed: *const guint32,
                                      seed_length: guint) -> *mut GRand;
    pub fn g_rand_new() -> *mut GRand;
    pub fn g_rand_free(rand_: *mut GRand) -> ();
    pub fn g_rand_copy(rand_: *mut GRand) -> *mut GRand;
    pub fn g_rand_set_seed(rand_: *mut GRand, seed: guint32) -> ();
    pub fn g_rand_set_seed_array(rand_: *mut GRand, seed: *const guint32,
                                 seed_length: guint) -> ();
    pub fn g_rand_int(rand_: *mut GRand) -> guint32;
    pub fn g_rand_int_range(rand_: *mut GRand, begin: gint32, end: gint32)
     -> gint32;
    pub fn g_rand_double(rand_: *mut GRand) -> gdouble;
    pub fn g_rand_double_range(rand_: *mut GRand, begin: gdouble,
                               end: gdouble) -> gdouble;
    pub fn g_random_set_seed(seed: guint32) -> ();
    pub fn g_random_int() -> guint32;
    pub fn g_random_int_range(begin: gint32, end: gint32) -> gint32;
    pub fn g_random_double() -> gdouble;
    pub fn g_random_double_range(begin: gdouble, end: gdouble) -> gdouble;
    pub fn g_regex_error_quark() -> GQuark;
    pub fn g_regex_new(pattern: *const gchar,
                       compile_options: GRegexCompileFlags,
                       match_options: GRegexMatchFlags,
                       error: *mut *mut GError) -> *mut GRegex;
    pub fn g_regex_ref(regex: *mut GRegex) -> *mut GRegex;
    pub fn g_regex_unref(regex: *mut GRegex) -> ();
    pub fn g_regex_get_pattern(regex: *const GRegex) -> *const gchar;
    pub fn g_regex_get_max_backref(regex: *const GRegex) -> gint;
    pub fn g_regex_get_capture_count(regex: *const GRegex) -> gint;
    pub fn g_regex_get_has_cr_or_lf(regex: *const GRegex) -> gboolean;
    pub fn g_regex_get_max_lookbehind(regex: *const GRegex) -> gint;
    pub fn g_regex_get_string_number(regex: *const GRegex, name: *const gchar)
     -> gint;
    pub fn g_regex_escape_string(string: *const gchar, length: gint)
     -> *mut gchar;
    pub fn g_regex_escape_nul(string: *const gchar, length: gint)
     -> *mut gchar;
    pub fn g_regex_get_compile_flags(regex: *const GRegex)
     -> GRegexCompileFlags;
    pub fn g_regex_get_match_flags(regex: *const GRegex) -> GRegexMatchFlags;
    pub fn g_regex_match_simple(pattern: *const gchar, string: *const gchar,
                                compile_options: GRegexCompileFlags,
                                match_options: GRegexMatchFlags) -> gboolean;
    pub fn g_regex_match(regex: *const GRegex, string: *const gchar,
                         match_options: GRegexMatchFlags,
                         match_info: *mut *mut GMatchInfo) -> gboolean;
    pub fn g_regex_match_full(regex: *const GRegex, string: *const gchar,
                              string_len: gssize, start_position: gint,
                              match_options: GRegexMatchFlags,
                              match_info: *mut *mut GMatchInfo,
                              error: *mut *mut GError) -> gboolean;
    pub fn g_regex_match_all(regex: *const GRegex, string: *const gchar,
                             match_options: GRegexMatchFlags,
                             match_info: *mut *mut GMatchInfo) -> gboolean;
    pub fn g_regex_match_all_full(regex: *const GRegex, string: *const gchar,
                                  string_len: gssize, start_position: gint,
                                  match_options: GRegexMatchFlags,
                                  match_info: *mut *mut GMatchInfo,
                                  error: *mut *mut GError) -> gboolean;
    pub fn g_regex_split_simple(pattern: *const gchar, string: *const gchar,
                                compile_options: GRegexCompileFlags,
                                match_options: GRegexMatchFlags)
     -> *mut *mut gchar;
    pub fn g_regex_split(regex: *const GRegex, string: *const gchar,
                         match_options: GRegexMatchFlags) -> *mut *mut gchar;
    pub fn g_regex_split_full(regex: *const GRegex, string: *const gchar,
                              string_len: gssize, start_position: gint,
                              match_options: GRegexMatchFlags,
                              max_tokens: gint, error: *mut *mut GError)
     -> *mut *mut gchar;
    pub fn g_regex_replace(regex: *const GRegex, string: *const gchar,
                           string_len: gssize, start_position: gint,
                           replacement: *const gchar,
                           match_options: GRegexMatchFlags,
                           error: *mut *mut GError) -> *mut gchar;
    pub fn g_regex_replace_literal(regex: *const GRegex, string: *const gchar,
                                   string_len: gssize, start_position: gint,
                                   replacement: *const gchar,
                                   match_options: GRegexMatchFlags,
                                   error: *mut *mut GError) -> *mut gchar;
    pub fn g_regex_replace_eval(regex: *const GRegex, string: *const gchar,
                                string_len: gssize, start_position: gint,
                                match_options: GRegexMatchFlags,
                                eval: GRegexEvalCallback, user_data: gpointer,
                                error: *mut *mut GError) -> *mut gchar;
    pub fn g_regex_check_replacement(replacement: *const gchar,
                                     has_references: *mut gboolean,
                                     error: *mut *mut GError) -> gboolean;
    pub fn g_match_info_get_regex(match_info: *const GMatchInfo)
     -> *mut GRegex;
    pub fn g_match_info_get_string(match_info: *const GMatchInfo)
     -> *const gchar;
    pub fn g_match_info_ref(match_info: *mut GMatchInfo) -> *mut GMatchInfo;
    pub fn g_match_info_unref(match_info: *mut GMatchInfo) -> ();
    pub fn g_match_info_free(match_info: *mut GMatchInfo) -> ();
    pub fn g_match_info_next(match_info: *mut GMatchInfo,
                             error: *mut *mut GError) -> gboolean;
    pub fn g_match_info_matches(match_info: *const GMatchInfo) -> gboolean;
    pub fn g_match_info_get_match_count(match_info: *const GMatchInfo)
     -> gint;
    pub fn g_match_info_is_partial_match(match_info: *const GMatchInfo)
     -> gboolean;
    pub fn g_match_info_expand_references(match_info: *const GMatchInfo,
                                          string_to_expand: *const gchar,
                                          error: *mut *mut GError)
     -> *mut gchar;
    pub fn g_match_info_fetch(match_info: *const GMatchInfo, match_num: gint)
     -> *mut gchar;
    pub fn g_match_info_fetch_pos(match_info: *const GMatchInfo,
                                  match_num: gint, start_pos: *mut gint,
                                  end_pos: *mut gint) -> gboolean;
    pub fn g_match_info_fetch_named(match_info: *const GMatchInfo,
                                    name: *const gchar) -> *mut gchar;
    pub fn g_match_info_fetch_named_pos(match_info: *const GMatchInfo,
                                        name: *const gchar,
                                        start_pos: *mut gint,
                                        end_pos: *mut gint) -> gboolean;
    pub fn g_match_info_fetch_all(match_info: *const GMatchInfo)
     -> *mut *mut gchar;
    pub fn g_scanner_new(config_templ: *const GScannerConfig)
     -> *mut GScanner;
    pub fn g_scanner_destroy(scanner: *mut GScanner) -> ();
    pub fn g_scanner_input_file(scanner: *mut GScanner, input_fd: gint) -> ();
    pub fn g_scanner_sync_file_offset(scanner: *mut GScanner) -> ();
    pub fn g_scanner_input_text(scanner: *mut GScanner, text: *const gchar,
                                text_len: guint) -> ();
    pub fn g_scanner_get_next_token(scanner: *mut GScanner) -> GTokenType;
    pub fn g_scanner_peek_next_token(scanner: *mut GScanner) -> GTokenType;
    pub fn g_scanner_cur_token(scanner: *mut GScanner) -> GTokenType;
    pub fn g_scanner_cur_value(scanner: *mut GScanner) -> GTokenValue;
    pub fn g_scanner_cur_line(scanner: *mut GScanner) -> guint;
    pub fn g_scanner_cur_position(scanner: *mut GScanner) -> guint;
    pub fn g_scanner_eof(scanner: *mut GScanner) -> gboolean;
    pub fn g_scanner_set_scope(scanner: *mut GScanner, scope_id: guint)
     -> guint;
    pub fn g_scanner_scope_add_symbol(scanner: *mut GScanner, scope_id: guint,
                                      symbol: *const gchar, value: gpointer)
     -> ();
    pub fn g_scanner_scope_remove_symbol(scanner: *mut GScanner,
                                         scope_id: guint,
                                         symbol: *const gchar) -> ();
    pub fn g_scanner_scope_lookup_symbol(scanner: *mut GScanner,
                                         scope_id: guint,
                                         symbol: *const gchar) -> gpointer;
    pub fn g_scanner_scope_foreach_symbol(scanner: *mut GScanner,
                                          scope_id: guint, func: GHFunc,
                                          user_data: gpointer) -> ();
    pub fn g_scanner_lookup_symbol(scanner: *mut GScanner,
                                   symbol: *const gchar) -> gpointer;
    pub fn g_scanner_unexp_token(scanner: *mut GScanner,
                                 expected_token: GTokenType,
                                 identifier_spec: *const gchar,
                                 symbol_spec: *const gchar,
                                 symbol_name: *const gchar,
                                 message: *const gchar, is_error: gint) -> ();
    pub fn g_scanner_error(scanner: *mut GScanner, format: *const gchar, ...)
     -> ();
    pub fn g_scanner_warn(scanner: *mut GScanner, format: *const gchar, ...)
     -> ();
    pub fn g_sequence_new(data_destroy: GDestroyNotify) -> *mut GSequence;
    pub fn g_sequence_free(seq: *mut GSequence) -> ();
    pub fn g_sequence_get_length(seq: *mut GSequence) -> gint;
    pub fn g_sequence_foreach(seq: *mut GSequence, func: GFunc,
                              user_data: gpointer) -> ();
    pub fn g_sequence_foreach_range(begin: *mut GSequenceIter,
                                    end: *mut GSequenceIter, func: GFunc,
                                    user_data: gpointer) -> ();
    pub fn g_sequence_sort(seq: *mut GSequence, cmp_func: GCompareDataFunc,
                           cmp_data: gpointer) -> ();
    pub fn g_sequence_sort_iter(seq: *mut GSequence,
                                cmp_func: GSequenceIterCompareFunc,
                                cmp_data: gpointer) -> ();
    pub fn g_sequence_get_begin_iter(seq: *mut GSequence)
     -> *mut GSequenceIter;
    pub fn g_sequence_get_end_iter(seq: *mut GSequence) -> *mut GSequenceIter;
    pub fn g_sequence_get_iter_at_pos(seq: *mut GSequence, pos: gint)
     -> *mut GSequenceIter;
    pub fn g_sequence_append(seq: *mut GSequence, data: gpointer)
     -> *mut GSequenceIter;
    pub fn g_sequence_prepend(seq: *mut GSequence, data: gpointer)
     -> *mut GSequenceIter;
    pub fn g_sequence_insert_before(iter: *mut GSequenceIter, data: gpointer)
     -> *mut GSequenceIter;
    pub fn g_sequence_move(src: *mut GSequenceIter, dest: *mut GSequenceIter)
     -> ();
    pub fn g_sequence_swap(a: *mut GSequenceIter, b: *mut GSequenceIter)
     -> ();
    pub fn g_sequence_insert_sorted(seq: *mut GSequence, data: gpointer,
                                    cmp_func: GCompareDataFunc,
                                    cmp_data: gpointer) -> *mut GSequenceIter;
    pub fn g_sequence_insert_sorted_iter(seq: *mut GSequence, data: gpointer,
                                         iter_cmp: GSequenceIterCompareFunc,
                                         cmp_data: gpointer)
     -> *mut GSequenceIter;
    pub fn g_sequence_sort_changed(iter: *mut GSequenceIter,
                                   cmp_func: GCompareDataFunc,
                                   cmp_data: gpointer) -> ();
    pub fn g_sequence_sort_changed_iter(iter: *mut GSequenceIter,
                                        iter_cmp: GSequenceIterCompareFunc,
                                        cmp_data: gpointer) -> ();
    pub fn g_sequence_remove(iter: *mut GSequenceIter) -> ();
    pub fn g_sequence_remove_range(begin: *mut GSequenceIter,
                                   end: *mut GSequenceIter) -> ();
    pub fn g_sequence_move_range(dest: *mut GSequenceIter,
                                 begin: *mut GSequenceIter,
                                 end: *mut GSequenceIter) -> ();
    pub fn g_sequence_search(seq: *mut GSequence, data: gpointer,
                             cmp_func: GCompareDataFunc, cmp_data: gpointer)
     -> *mut GSequenceIter;
    pub fn g_sequence_search_iter(seq: *mut GSequence, data: gpointer,
                                  iter_cmp: GSequenceIterCompareFunc,
                                  cmp_data: gpointer) -> *mut GSequenceIter;
    pub fn g_sequence_lookup(seq: *mut GSequence, data: gpointer,
                             cmp_func: GCompareDataFunc, cmp_data: gpointer)
     -> *mut GSequenceIter;
    pub fn g_sequence_lookup_iter(seq: *mut GSequence, data: gpointer,
                                  iter_cmp: GSequenceIterCompareFunc,
                                  cmp_data: gpointer) -> *mut GSequenceIter;
    pub fn g_sequence_get(iter: *mut GSequenceIter) -> gpointer;
    pub fn g_sequence_set(iter: *mut GSequenceIter, data: gpointer) -> ();
    pub fn g_sequence_iter_is_begin(iter: *mut GSequenceIter) -> gboolean;
    pub fn g_sequence_iter_is_end(iter: *mut GSequenceIter) -> gboolean;
    pub fn g_sequence_iter_next(iter: *mut GSequenceIter)
     -> *mut GSequenceIter;
    pub fn g_sequence_iter_prev(iter: *mut GSequenceIter)
     -> *mut GSequenceIter;
    pub fn g_sequence_iter_get_position(iter: *mut GSequenceIter) -> gint;
    pub fn g_sequence_iter_move(iter: *mut GSequenceIter, delta: gint)
     -> *mut GSequenceIter;
    pub fn g_sequence_iter_get_sequence(iter: *mut GSequenceIter)
     -> *mut GSequence;
    pub fn g_sequence_iter_compare(a: *mut GSequenceIter,
                                   b: *mut GSequenceIter) -> gint;
    pub fn g_sequence_range_get_midpoint(begin: *mut GSequenceIter,
                                         end: *mut GSequenceIter)
     -> *mut GSequenceIter;
    pub fn g_shell_error_quark() -> GQuark;
    pub fn g_shell_quote(unquoted_string: *const gchar) -> *mut gchar;
    pub fn g_shell_unquote(quoted_string: *const gchar,
                           error: *mut *mut GError) -> *mut gchar;
    pub fn g_shell_parse_argv(command_line: *const gchar, argcp: *mut gint,
                              argvp: *mut *mut *mut gchar,
                              error: *mut *mut GError) -> gboolean;
    pub fn g_slice_alloc(block_size: gsize) -> gpointer;
    pub fn g_slice_alloc0(block_size: gsize) -> gpointer;
    pub fn g_slice_copy(block_size: gsize, mem_block: gconstpointer)
     -> gpointer;
    pub fn g_slice_free1(block_size: gsize, mem_block: gpointer) -> ();
    pub fn g_slice_free_chain_with_offset(block_size: gsize,
                                          mem_chain: gpointer,
                                          next_offset: gsize) -> ();
    pub fn g_slice_set_config(ckey: GSliceConfig, value: gint64) -> ();
    pub fn g_slice_get_config(ckey: GSliceConfig) -> gint64;
    pub fn g_slice_get_config_state(ckey: GSliceConfig, address: gint64,
                                    n_values: *mut guint) -> *mut gint64;
    pub fn g_spawn_error_quark() -> GQuark;
    pub fn g_spawn_exit_error_quark() -> GQuark;
    pub fn g_spawn_async(working_directory: *const gchar,
                         argv: *mut *mut gchar, envp: *mut *mut gchar,
                         flags: GSpawnFlags,
                         child_setup: GSpawnChildSetupFunc,
                         user_data: gpointer, child_pid: *mut GPid,
                         error: *mut *mut GError) -> gboolean;
    pub fn g_spawn_async_with_pipes(working_directory: *const gchar,
                                    argv: *mut *mut gchar,
                                    envp: *mut *mut gchar, flags: GSpawnFlags,
                                    child_setup: GSpawnChildSetupFunc,
                                    user_data: gpointer, child_pid: *mut GPid,
                                    standard_input: *mut gint,
                                    standard_output: *mut gint,
                                    standard_error: *mut gint,
                                    error: *mut *mut GError) -> gboolean;
    pub fn g_spawn_sync(working_directory: *const gchar,
                        argv: *mut *mut gchar, envp: *mut *mut gchar,
                        flags: GSpawnFlags, child_setup: GSpawnChildSetupFunc,
                        user_data: gpointer, standard_output: *mut *mut gchar,
                        standard_error: *mut *mut gchar,
                        exit_status: *mut gint, error: *mut *mut GError)
     -> gboolean;
    pub fn g_spawn_command_line_sync(command_line: *const gchar,
                                     standard_output: *mut *mut gchar,
                                     standard_error: *mut *mut gchar,
                                     exit_status: *mut gint,
                                     error: *mut *mut GError) -> gboolean;
    pub fn g_spawn_command_line_async(command_line: *const gchar,
                                      error: *mut *mut GError) -> gboolean;
    pub fn g_spawn_check_exit_status(exit_status: gint,
                                     error: *mut *mut GError) -> gboolean;
    pub fn g_spawn_close_pid(pid: GPid) -> ();
    pub fn g_ascii_tolower(c: gchar) -> gchar;
    pub fn g_ascii_toupper(c: gchar) -> gchar;
    pub fn g_ascii_digit_value(c: gchar) -> gint;
    pub fn g_ascii_xdigit_value(c: gchar) -> gint;
    pub fn g_strdelimit(string: *mut gchar, delimiters: *const gchar,
                        new_delimiter: gchar) -> *mut gchar;
    pub fn g_strcanon(string: *mut gchar, valid_chars: *const gchar,
                      substitutor: gchar) -> *mut gchar;
    pub fn g_strerror(errnum: gint) -> *const gchar;
    pub fn g_strsignal(signum: gint) -> *const gchar;
    pub fn g_strreverse(string: *mut gchar) -> *mut gchar;
    pub fn g_strlcpy(dest: *mut gchar, src: *const gchar, dest_size: gsize)
     -> gsize;
    pub fn g_strlcat(dest: *mut gchar, src: *const gchar, dest_size: gsize)
     -> gsize;
    pub fn g_strstr_len(haystack: *const gchar, haystack_len: gssize,
                        needle: *const gchar) -> *mut gchar;
    pub fn g_strrstr(haystack: *const gchar, needle: *const gchar)
     -> *mut gchar;
    pub fn g_strrstr_len(haystack: *const gchar, haystack_len: gssize,
                         needle: *const gchar) -> *mut gchar;
    pub fn g_str_has_suffix(str: *const gchar, suffix: *const gchar)
     -> gboolean;
    pub fn g_str_has_prefix(str: *const gchar, prefix: *const gchar)
     -> gboolean;
    pub fn g_strtod(nptr: *const gchar, endptr: *mut *mut gchar) -> gdouble;
    pub fn g_ascii_strtod(nptr: *const gchar, endptr: *mut *mut gchar)
     -> gdouble;
    pub fn g_ascii_strtoull(nptr: *const gchar, endptr: *mut *mut gchar,
                            base: guint) -> guint64;
    pub fn g_ascii_strtoll(nptr: *const gchar, endptr: *mut *mut gchar,
                           base: guint) -> gint64;
    pub fn g_ascii_dtostr(buffer: *mut gchar, buf_len: gint, d: gdouble)
     -> *mut gchar;
    pub fn g_ascii_formatd(buffer: *mut gchar, buf_len: gint,
                           format: *const gchar, d: gdouble) -> *mut gchar;
    pub fn g_strchug(string: *mut gchar) -> *mut gchar;
    pub fn g_strchomp(string: *mut gchar) -> *mut gchar;
    pub fn g_ascii_strcasecmp(s1: *const gchar, s2: *const gchar) -> gint;
    pub fn g_ascii_strncasecmp(s1: *const gchar, s2: *const gchar, n: gsize)
     -> gint;
    pub fn g_ascii_strdown(str: *const gchar, len: gssize) -> *mut gchar;
    pub fn g_ascii_strup(str: *const gchar, len: gssize) -> *mut gchar;
    pub fn g_str_is_ascii(str: *const gchar) -> gboolean;
    pub fn g_strcasecmp(s1: *const gchar, s2: *const gchar) -> gint;
    pub fn g_strncasecmp(s1: *const gchar, s2: *const gchar, n: guint)
     -> gint;
    pub fn g_strdown(string: *mut gchar) -> *mut gchar;
    pub fn g_strup(string: *mut gchar) -> *mut gchar;
    pub fn g_strdup(str: *const gchar) -> *mut gchar;
    pub fn g_strdup_printf(format: *const gchar, ...) -> *mut gchar;
    pub fn g_strdup_vprintf(format: *const gchar, args: va_list)
     -> *mut gchar;
    pub fn g_strndup(str: *const gchar, n: gsize) -> *mut gchar;
    pub fn g_strnfill(length: gsize, fill_char: gchar) -> *mut gchar;
    pub fn g_strconcat(string1: *const gchar, ...) -> *mut gchar;
    pub fn g_strjoin(separator: *const gchar, ...) -> *mut gchar;
    pub fn g_strcompress(source: *const gchar) -> *mut gchar;
    pub fn g_strescape(source: *const gchar, exceptions: *const gchar)
     -> *mut gchar;
    pub fn g_memdup(mem: gconstpointer, byte_size: guint) -> gpointer;
    pub fn g_strsplit(string: *const gchar, delimiter: *const gchar,
                      max_tokens: gint) -> *mut *mut gchar;
    pub fn g_strsplit_set(string: *const gchar, delimiters: *const gchar,
                          max_tokens: gint) -> *mut *mut gchar;
    pub fn g_strjoinv(separator: *const gchar, str_array: *mut *mut gchar)
     -> *mut gchar;
    pub fn g_strfreev(str_array: *mut *mut gchar) -> ();
    pub fn g_strdupv(str_array: *mut *mut gchar) -> *mut *mut gchar;
    pub fn g_strv_length(str_array: *mut *mut gchar) -> guint;
    pub fn g_stpcpy(dest: *mut gchar, src: *const ::libc::c_char)
     -> *mut gchar;
    pub fn g_str_to_ascii(str: *const gchar, from_locale: *const gchar)
     -> *mut gchar;
    pub fn g_str_tokenize_and_fold(string: *const gchar,
                                   translit_locale: *const gchar,
                                   ascii_alternates: *mut *mut *mut gchar)
     -> *mut *mut gchar;
    pub fn g_str_match_string(search_term: *const gchar,
                              potential_hit: *const gchar,
                              accept_alternates: gboolean) -> gboolean;
    pub fn g_string_chunk_new(size: gsize) -> *mut GStringChunk;
    pub fn g_string_chunk_free(chunk: *mut GStringChunk) -> ();
    pub fn g_string_chunk_clear(chunk: *mut GStringChunk) -> ();
    pub fn g_string_chunk_insert(chunk: *mut GStringChunk,
                                 string: *const gchar) -> *mut gchar;
    pub fn g_string_chunk_insert_len(chunk: *mut GStringChunk,
                                     string: *const gchar, len: gssize)
     -> *mut gchar;
    pub fn g_string_chunk_insert_const(chunk: *mut GStringChunk,
                                       string: *const gchar) -> *mut gchar;
    pub fn g_strcmp0(str1: *const ::libc::c_char, str2: *const ::libc::c_char)
     -> ::libc::c_int;
    pub fn g_test_minimized_result(minimized_quantity: ::libc::c_double,
                                   format: *const ::libc::c_char, ...) -> ();
    pub fn g_test_maximized_result(maximized_quantity: ::libc::c_double,
                                   format: *const ::libc::c_char, ...) -> ();
    pub fn g_test_init(argc: *mut ::libc::c_int,
                       argv: *mut *mut *mut ::libc::c_char, ...) -> ();
    pub fn g_test_subprocess() -> gboolean;
    pub fn g_test_run() -> ::libc::c_int;
    pub fn g_test_add_func(testpath: *const ::libc::c_char,
                           test_func: GTestFunc) -> ();
    pub fn g_test_add_data_func(testpath: *const ::libc::c_char,
                                test_data: gconstpointer,
                                test_func: GTestDataFunc) -> ();
    pub fn g_test_add_data_func_full(testpath: *const ::libc::c_char,
                                     test_data: gpointer,
                                     test_func: GTestDataFunc,
                                     data_free_func: GDestroyNotify) -> ();
    pub fn g_test_fail() -> ();
    pub fn g_test_incomplete(msg: *const gchar) -> ();
    pub fn g_test_skip(msg: *const gchar) -> ();
    pub fn g_test_failed() -> gboolean;
    pub fn g_test_set_nonfatal_assertions() -> ();
    pub fn g_test_message(format: *const ::libc::c_char, ...) -> ();
    pub fn g_test_bug_base(uri_pattern: *const ::libc::c_char) -> ();
    pub fn g_test_bug(bug_uri_snippet: *const ::libc::c_char) -> ();
    pub fn g_test_timer_start() -> ();
    pub fn g_test_timer_elapsed() -> ::libc::c_double;
    pub fn g_test_timer_last() -> ::libc::c_double;
    pub fn g_test_queue_free(gfree_pointer: gpointer) -> ();
    pub fn g_test_queue_destroy(destroy_func: GDestroyNotify,
                                destroy_data: gpointer) -> ();
    pub fn g_test_trap_fork(usec_timeout: guint64,
                            test_trap_flags: GTestTrapFlags) -> gboolean;
    pub fn g_test_trap_subprocess(test_path: *const ::libc::c_char,
                                  usec_timeout: guint64,
                                  test_flags: GTestSubprocessFlags) -> ();
    pub fn g_test_trap_has_passed() -> gboolean;
    pub fn g_test_trap_reached_timeout() -> gboolean;
    pub fn g_test_rand_int() -> gint32;
    pub fn g_test_rand_int_range(begin: gint32, end: gint32) -> gint32;
    pub fn g_test_rand_double() -> ::libc::c_double;
    pub fn g_test_rand_double_range(range_start: ::libc::c_double,
                                    range_end: ::libc::c_double)
     -> ::libc::c_double;
    pub fn g_test_create_case(test_name: *const ::libc::c_char,
                              data_size: gsize, test_data: gconstpointer,
                              data_setup: GTestFixtureFunc,
                              data_test: GTestFixtureFunc,
                              data_teardown: GTestFixtureFunc)
     -> *mut GTestCase;
    pub fn g_test_create_suite(suite_name: *const ::libc::c_char)
     -> *mut GTestSuite;
    pub fn g_test_get_root() -> *mut GTestSuite;
    pub fn g_test_suite_add(suite: *mut GTestSuite, test_case: *mut GTestCase)
     -> ();
    pub fn g_test_suite_add_suite(suite: *mut GTestSuite,
                                  nestedsuite: *mut GTestSuite) -> ();
    pub fn g_test_run_suite(suite: *mut GTestSuite) -> ::libc::c_int;
    pub fn g_test_trap_assertions(domain: *const ::libc::c_char,
                                  file: *const ::libc::c_char,
                                  line: ::libc::c_int,
                                  func: *const ::libc::c_char,
                                  assertion_flags: guint64,
                                  pattern: *const ::libc::c_char) -> ();
    pub fn g_assertion_message(domain: *const ::libc::c_char,
                               file: *const ::libc::c_char,
                               line: ::libc::c_int,
                               func: *const ::libc::c_char,
                               message: *const ::libc::c_char) -> ();
    pub fn g_assertion_message_expr(domain: *const ::libc::c_char,
                                    file: *const ::libc::c_char,
                                    line: ::libc::c_int,
                                    func: *const ::libc::c_char,
                                    expr: *const ::libc::c_char) -> ();
    pub fn g_assertion_message_cmpstr(domain: *const ::libc::c_char,
                                      file: *const ::libc::c_char,
                                      line: ::libc::c_int,
                                      func: *const ::libc::c_char,
                                      expr: *const ::libc::c_char,
                                      arg1: *const ::libc::c_char,
                                      cmp: *const ::libc::c_char,
                                      arg2: *const ::libc::c_char) -> ();
    pub fn g_assertion_message_cmpnum(domain: *const ::libc::c_char,
                                      file: *const ::libc::c_char,
                                      line: ::libc::c_int,
                                      func: *const ::libc::c_char,
                                      expr: *const ::libc::c_char,
                                      arg1: ::libc::c_double,
                                      cmp: *const ::libc::c_char,
                                      arg2: ::libc::c_double,
                                      numtype: ::libc::c_char) -> ();
    pub fn g_assertion_message_error(domain: *const ::libc::c_char,
                                     file: *const ::libc::c_char,
                                     line: ::libc::c_int,
                                     func: *const ::libc::c_char,
                                     expr: *const ::libc::c_char,
                                     error: *const GError,
                                     error_domain: GQuark,
                                     error_code: ::libc::c_int) -> ();
    pub fn g_test_add_vtable(testpath: *const ::libc::c_char,
                             data_size: gsize, test_data: gconstpointer,
                             data_setup: GTestFixtureFunc,
                             data_test: GTestFixtureFunc,
                             data_teardown: GTestFixtureFunc) -> ();
    pub fn g_test_log_type_name(log_type: GTestLogType)
     -> *const ::libc::c_char;
    pub fn g_test_log_buffer_new() -> *mut GTestLogBuffer;
    pub fn g_test_log_buffer_free(tbuffer: *mut GTestLogBuffer) -> ();
    pub fn g_test_log_buffer_push(tbuffer: *mut GTestLogBuffer,
                                  n_bytes: guint, bytes: *const guint8) -> ();
    pub fn g_test_log_buffer_pop(tbuffer: *mut GTestLogBuffer)
     -> *mut GTestLogMsg;
    pub fn g_test_log_msg_free(tmsg: *mut GTestLogMsg) -> ();
    pub fn g_test_log_set_fatal_handler(log_func: GTestLogFatalFunc,
                                        user_data: gpointer) -> ();
    pub fn g_test_expect_message(log_domain: *const gchar,
                                 log_level: GLogLevelFlags,
                                 pattern: *const gchar) -> ();
    pub fn g_test_assert_expected_messages_internal(domain:
                                                        *const ::libc::c_char,
                                                    file:
                                                        *const ::libc::c_char,
                                                    line: ::libc::c_int,
                                                    func:
                                                        *const ::libc::c_char)
     -> ();
    pub fn g_test_build_filename(file_type: GTestFileType,
                                 first_path: *const gchar, ...) -> *mut gchar;
    pub fn g_test_get_dir(file_type: GTestFileType) -> *const gchar;
    pub fn g_test_get_filename(file_type: GTestFileType,
                               first_path: *const gchar, ...) -> *const gchar;
    pub fn g_thread_pool_new(func: GFunc, user_data: gpointer,
                             max_threads: gint, exclusive: gboolean,
                             error: *mut *mut GError) -> *mut GThreadPool;
    pub fn g_thread_pool_free(pool: *mut GThreadPool, immediate: gboolean,
                              wait_: gboolean) -> ();
    pub fn g_thread_pool_push(pool: *mut GThreadPool, data: gpointer,
                              error: *mut *mut GError) -> gboolean;
    pub fn g_thread_pool_unprocessed(pool: *mut GThreadPool) -> guint;
    pub fn g_thread_pool_set_sort_function(pool: *mut GThreadPool,
                                           func: GCompareDataFunc,
                                           user_data: gpointer) -> ();
    pub fn g_thread_pool_set_max_threads(pool: *mut GThreadPool,
                                         max_threads: gint,
                                         error: *mut *mut GError) -> gboolean;
    pub fn g_thread_pool_get_max_threads(pool: *mut GThreadPool) -> gint;
    pub fn g_thread_pool_get_num_threads(pool: *mut GThreadPool) -> guint;
    pub fn g_thread_pool_set_max_unused_threads(max_threads: gint) -> ();
    pub fn g_thread_pool_get_max_unused_threads() -> gint;
    pub fn g_thread_pool_get_num_unused_threads() -> guint;
    pub fn g_thread_pool_stop_unused_threads() -> ();
    pub fn g_thread_pool_set_max_idle_time(interval: guint) -> ();
    pub fn g_thread_pool_get_max_idle_time() -> guint;
    pub fn g_timer_new() -> *mut GTimer;
    pub fn g_timer_destroy(timer: *mut GTimer) -> ();
    pub fn g_timer_start(timer: *mut GTimer) -> ();
    pub fn g_timer_stop(timer: *mut GTimer) -> ();
    pub fn g_timer_reset(timer: *mut GTimer) -> ();
    pub fn g_timer_continue(timer: *mut GTimer) -> ();
    pub fn g_timer_elapsed(timer: *mut GTimer, microseconds: *mut gulong)
     -> gdouble;
    pub fn g_usleep(microseconds: gulong) -> ();
    pub fn g_time_val_add(time_: *mut GTimeVal, microseconds: glong) -> ();
    pub fn g_time_val_from_iso8601(iso_date: *const gchar,
                                   time_: *mut GTimeVal) -> gboolean;
    pub fn g_time_val_to_iso8601(time_: *mut GTimeVal) -> *mut gchar;
    pub fn g_tree_new(key_compare_func: GCompareFunc) -> *mut GTree;
    pub fn g_tree_new_with_data(key_compare_func: GCompareDataFunc,
                                key_compare_data: gpointer) -> *mut GTree;
    pub fn g_tree_new_full(key_compare_func: GCompareDataFunc,
                           key_compare_data: gpointer,
                           key_destroy_func: GDestroyNotify,
                           value_destroy_func: GDestroyNotify) -> *mut GTree;
    pub fn g_tree_ref(tree: *mut GTree) -> *mut GTree;
    pub fn g_tree_unref(tree: *mut GTree) -> ();
    pub fn g_tree_destroy(tree: *mut GTree) -> ();
    pub fn g_tree_insert(tree: *mut GTree, key: gpointer, value: gpointer)
     -> ();
    pub fn g_tree_replace(tree: *mut GTree, key: gpointer, value: gpointer)
     -> ();
    pub fn g_tree_remove(tree: *mut GTree, key: gconstpointer) -> gboolean;
    pub fn g_tree_steal(tree: *mut GTree, key: gconstpointer) -> gboolean;
    pub fn g_tree_lookup(tree: *mut GTree, key: gconstpointer) -> gpointer;
    pub fn g_tree_lookup_extended(tree: *mut GTree, lookup_key: gconstpointer,
                                  orig_key: *mut gpointer,
                                  value: *mut gpointer) -> gboolean;
    pub fn g_tree_foreach(tree: *mut GTree, func: GTraverseFunc,
                          user_data: gpointer) -> ();
    pub fn g_tree_traverse(tree: *mut GTree, traverse_func: GTraverseFunc,
                           traverse_type: GTraverseType, user_data: gpointer)
     -> ();
    pub fn g_tree_search(tree: *mut GTree, search_func: GCompareFunc,
                         user_data: gconstpointer) -> gpointer;
    pub fn g_tree_height(tree: *mut GTree) -> gint;
    pub fn g_tree_nnodes(tree: *mut GTree) -> gint;
    pub fn g_uri_unescape_string(escaped_string: *const ::libc::c_char,
                                 illegal_characters: *const ::libc::c_char)
     -> *mut ::libc::c_char;
    pub fn g_uri_unescape_segment(escaped_string: *const ::libc::c_char,
                                  escaped_string_end: *const ::libc::c_char,
                                  illegal_characters: *const ::libc::c_char)
     -> *mut ::libc::c_char;
    pub fn g_uri_parse_scheme(uri: *const ::libc::c_char)
     -> *mut ::libc::c_char;
    pub fn g_uri_escape_string(unescaped: *const ::libc::c_char,
                               reserved_chars_allowed: *const ::libc::c_char,
                               allow_utf8: gboolean) -> *mut ::libc::c_char;
    pub fn g_variant_type_string_is_valid(type_string: *const gchar)
     -> gboolean;
    pub fn g_variant_type_string_scan(string: *const gchar,
                                      limit: *const gchar,
                                      endptr: *mut *const gchar) -> gboolean;
    pub fn g_variant_type_free(_type: *mut GVariantType) -> ();
    pub fn g_variant_type_copy(_type: *const GVariantType)
     -> *mut GVariantType;
    pub fn g_variant_type_new(type_string: *const gchar) -> *mut GVariantType;
    pub fn g_variant_type_get_string_length(_type: *const GVariantType)
     -> gsize;
    pub fn g_variant_type_peek_string(_type: *const GVariantType)
     -> *const gchar;
    pub fn g_variant_type_dup_string(_type: *const GVariantType)
     -> *mut gchar;
    pub fn g_variant_type_is_definite(_type: *const GVariantType) -> gboolean;
    pub fn g_variant_type_is_container(_type: *const GVariantType)
     -> gboolean;
    pub fn g_variant_type_is_basic(_type: *const GVariantType) -> gboolean;
    pub fn g_variant_type_is_maybe(_type: *const GVariantType) -> gboolean;
    pub fn g_variant_type_is_array(_type: *const GVariantType) -> gboolean;
    pub fn g_variant_type_is_tuple(_type: *const GVariantType) -> gboolean;
    pub fn g_variant_type_is_dict_entry(_type: *const GVariantType)
     -> gboolean;
    pub fn g_variant_type_is_variant(_type: *const GVariantType) -> gboolean;
    pub fn g_variant_type_hash(_type: gconstpointer) -> guint;
    pub fn g_variant_type_equal(type1: gconstpointer, type2: gconstpointer)
     -> gboolean;
    pub fn g_variant_type_is_subtype_of(_type: *const GVariantType,
                                        supertype: *const GVariantType)
     -> gboolean;
    pub fn g_variant_type_element(_type: *const GVariantType)
     -> *const GVariantType;
    pub fn g_variant_type_first(_type: *const GVariantType)
     -> *const GVariantType;
    pub fn g_variant_type_next(_type: *const GVariantType)
     -> *const GVariantType;
    pub fn g_variant_type_n_items(_type: *const GVariantType) -> gsize;
    pub fn g_variant_type_key(_type: *const GVariantType)
     -> *const GVariantType;
    pub fn g_variant_type_value(_type: *const GVariantType)
     -> *const GVariantType;
    pub fn g_variant_type_new_array(element: *const GVariantType)
     -> *mut GVariantType;
    pub fn g_variant_type_new_maybe(element: *const GVariantType)
     -> *mut GVariantType;
    pub fn g_variant_type_new_tuple(items: *const *const GVariantType,
                                    length: gint) -> *mut GVariantType;
    pub fn g_variant_type_new_dict_entry(key: *const GVariantType,
                                         value: *const GVariantType)
     -> *mut GVariantType;
    pub fn g_variant_type_checked_(arg1: *const gchar) -> *const GVariantType;
    pub fn g_variant_unref(value: *mut GVariant) -> ();
    pub fn g_variant_ref(value: *mut GVariant) -> *mut GVariant;
    pub fn g_variant_ref_sink(value: *mut GVariant) -> *mut GVariant;
    pub fn g_variant_is_floating(value: *mut GVariant) -> gboolean;
    pub fn g_variant_take_ref(value: *mut GVariant) -> *mut GVariant;
    pub fn g_variant_get_type(value: *mut GVariant) -> *const GVariantType;
    pub fn g_variant_get_type_string(value: *mut GVariant) -> *const gchar;
    pub fn g_variant_is_of_type(value: *mut GVariant,
                                _type: *const GVariantType) -> gboolean;
    pub fn g_variant_is_container(value: *mut GVariant) -> gboolean;
    pub fn g_variant_classify(value: *mut GVariant) -> GVariantClass;
    pub fn g_variant_new_boolean(value: gboolean) -> *mut GVariant;
    pub fn g_variant_new_byte(value: guchar) -> *mut GVariant;
    pub fn g_variant_new_int16(value: gint16) -> *mut GVariant;
    pub fn g_variant_new_uint16(value: guint16) -> *mut GVariant;
    pub fn g_variant_new_int32(value: gint32) -> *mut GVariant;
    pub fn g_variant_new_uint32(value: guint32) -> *mut GVariant;
    pub fn g_variant_new_int64(value: gint64) -> *mut GVariant;
    pub fn g_variant_new_uint64(value: guint64) -> *mut GVariant;
    pub fn g_variant_new_handle(value: gint32) -> *mut GVariant;
    pub fn g_variant_new_double(value: gdouble) -> *mut GVariant;
    pub fn g_variant_new_string(string: *const gchar) -> *mut GVariant;
    pub fn g_variant_new_take_string(string: *mut gchar) -> *mut GVariant;
    pub fn g_variant_new_printf(format_string: *const gchar, ...)
     -> *mut GVariant;
    pub fn g_variant_new_object_path(object_path: *const gchar)
     -> *mut GVariant;
    pub fn g_variant_is_object_path(string: *const gchar) -> gboolean;
    pub fn g_variant_new_signature(signature: *const gchar) -> *mut GVariant;
    pub fn g_variant_is_signature(string: *const gchar) -> gboolean;
    pub fn g_variant_new_variant(value: *mut GVariant) -> *mut GVariant;
    pub fn g_variant_new_strv(strv: *const *const gchar, length: gssize)
     -> *mut GVariant;
    pub fn g_variant_new_objv(strv: *const *const gchar, length: gssize)
     -> *mut GVariant;
    pub fn g_variant_new_bytestring(string: *const gchar) -> *mut GVariant;
    pub fn g_variant_new_bytestring_array(strv: *const *const gchar,
                                          length: gssize) -> *mut GVariant;
    pub fn g_variant_new_fixed_array(element_type: *const GVariantType,
                                     elements: gconstpointer,
                                     n_elements: gsize, element_size: gsize)
     -> *mut GVariant;
    pub fn g_variant_get_boolean(value: *mut GVariant) -> gboolean;
    pub fn g_variant_get_byte(value: *mut GVariant) -> guchar;
    pub fn g_variant_get_int16(value: *mut GVariant) -> gint16;
    pub fn g_variant_get_uint16(value: *mut GVariant) -> guint16;
    pub fn g_variant_get_int32(value: *mut GVariant) -> gint32;
    pub fn g_variant_get_uint32(value: *mut GVariant) -> guint32;
    pub fn g_variant_get_int64(value: *mut GVariant) -> gint64;
    pub fn g_variant_get_uint64(value: *mut GVariant) -> guint64;
    pub fn g_variant_get_handle(value: *mut GVariant) -> gint32;
    pub fn g_variant_get_double(value: *mut GVariant) -> gdouble;
    pub fn g_variant_get_variant(value: *mut GVariant) -> *mut GVariant;
    pub fn g_variant_get_string(value: *mut GVariant, length: *mut gsize)
     -> *const gchar;
    pub fn g_variant_dup_string(value: *mut GVariant, length: *mut gsize)
     -> *mut gchar;
    pub fn g_variant_get_strv(value: *mut GVariant, length: *mut gsize)
     -> *mut *const gchar;
    pub fn g_variant_dup_strv(value: *mut GVariant, length: *mut gsize)
     -> *mut *mut gchar;
    pub fn g_variant_get_objv(value: *mut GVariant, length: *mut gsize)
     -> *mut *const gchar;
    pub fn g_variant_dup_objv(value: *mut GVariant, length: *mut gsize)
     -> *mut *mut gchar;
    pub fn g_variant_get_bytestring(value: *mut GVariant) -> *const gchar;
    pub fn g_variant_dup_bytestring(value: *mut GVariant, length: *mut gsize)
     -> *mut gchar;
    pub fn g_variant_get_bytestring_array(value: *mut GVariant,
                                          length: *mut gsize)
     -> *mut *const gchar;
    pub fn g_variant_dup_bytestring_array(value: *mut GVariant,
                                          length: *mut gsize)
     -> *mut *mut gchar;
    pub fn g_variant_new_maybe(child_type: *const GVariantType,
                               child: *mut GVariant) -> *mut GVariant;
    pub fn g_variant_new_array(child_type: *const GVariantType,
                               children: *const *mut GVariant,
                               n_children: gsize) -> *mut GVariant;
    pub fn g_variant_new_tuple(children: *const *mut GVariant,
                               n_children: gsize) -> *mut GVariant;
    pub fn g_variant_new_dict_entry(key: *mut GVariant, value: *mut GVariant)
     -> *mut GVariant;
    pub fn g_variant_get_maybe(value: *mut GVariant) -> *mut GVariant;
    pub fn g_variant_n_children(value: *mut GVariant) -> gsize;
    pub fn g_variant_get_child(value: *mut GVariant, index_: gsize,
                               format_string: *const gchar, ...) -> ();
    pub fn g_variant_get_child_value(value: *mut GVariant, index_: gsize)
     -> *mut GVariant;
    pub fn g_variant_lookup(dictionary: *mut GVariant, key: *const gchar,
                            format_string: *const gchar, ...) -> gboolean;
    pub fn g_variant_lookup_value(dictionary: *mut GVariant,
                                  key: *const gchar,
                                  expected_type: *const GVariantType)
     -> *mut GVariant;
    pub fn g_variant_get_fixed_array(value: *mut GVariant,
                                     n_elements: *mut gsize,
                                     element_size: gsize) -> gconstpointer;
    pub fn g_variant_get_size(value: *mut GVariant) -> gsize;
    pub fn g_variant_get_data(value: *mut GVariant) -> gconstpointer;
    pub fn g_variant_get_data_as_bytes(value: *mut GVariant) -> *mut GBytes;
    pub fn g_variant_store(value: *mut GVariant, data: gpointer) -> ();
    pub fn g_variant_print(value: *mut GVariant, type_annotate: gboolean)
     -> *mut gchar;
    pub fn g_variant_print_string(value: *mut GVariant, string: *mut GString,
                                  type_annotate: gboolean) -> *mut GString;
    pub fn g_variant_hash(value: gconstpointer) -> guint;
    pub fn g_variant_equal(one: gconstpointer, two: gconstpointer)
     -> gboolean;
    pub fn g_variant_get_normal_form(value: *mut GVariant) -> *mut GVariant;
    pub fn g_variant_is_normal_form(value: *mut GVariant) -> gboolean;
    pub fn g_variant_byteswap(value: *mut GVariant) -> *mut GVariant;
    pub fn g_variant_new_from_bytes(_type: *const GVariantType,
                                    bytes: *mut GBytes, trusted: gboolean)
     -> *mut GVariant;
    pub fn g_variant_new_from_data(_type: *const GVariantType,
                                   data: gconstpointer, size: gsize,
                                   trusted: gboolean, notify: GDestroyNotify,
                                   user_data: gpointer) -> *mut GVariant;
    pub fn g_variant_iter_new(value: *mut GVariant) -> *mut GVariantIter;
    pub fn g_variant_iter_init(iter: *mut GVariantIter, value: *mut GVariant)
     -> gsize;
    pub fn g_variant_iter_copy(iter: *mut GVariantIter) -> *mut GVariantIter;
    pub fn g_variant_iter_n_children(iter: *mut GVariantIter) -> gsize;
    pub fn g_variant_iter_free(iter: *mut GVariantIter) -> ();
    pub fn g_variant_iter_next_value(iter: *mut GVariantIter)
     -> *mut GVariant;
    pub fn g_variant_iter_next(iter: *mut GVariantIter,
                               format_string: *const gchar, ...) -> gboolean;
    pub fn g_variant_iter_loop(iter: *mut GVariantIter,
                               format_string: *const gchar, ...) -> gboolean;
    pub fn g_variant_parser_get_error_quark() -> GQuark;
    pub fn g_variant_parse_error_quark() -> GQuark;
    pub fn g_variant_builder_new(_type: *const GVariantType)
     -> *mut GVariantBuilder;
    pub fn g_variant_builder_unref(builder: *mut GVariantBuilder) -> ();
    pub fn g_variant_builder_ref(builder: *mut GVariantBuilder)
     -> *mut GVariantBuilder;
    pub fn g_variant_builder_init(builder: *mut GVariantBuilder,
                                  _type: *const GVariantType) -> ();
    pub fn g_variant_builder_end(builder: *mut GVariantBuilder)
     -> *mut GVariant;
    pub fn g_variant_builder_clear(builder: *mut GVariantBuilder) -> ();
    pub fn g_variant_builder_open(builder: *mut GVariantBuilder,
                                  _type: *const GVariantType) -> ();
    pub fn g_variant_builder_close(builder: *mut GVariantBuilder) -> ();
    pub fn g_variant_builder_add_value(builder: *mut GVariantBuilder,
                                       value: *mut GVariant) -> ();
    pub fn g_variant_builder_add(builder: *mut GVariantBuilder,
                                 format_string: *const gchar, ...) -> ();
    pub fn g_variant_builder_add_parsed(builder: *mut GVariantBuilder,
                                        format: *const gchar, ...) -> ();
    pub fn g_variant_new(format_string: *const gchar, ...) -> *mut GVariant;
    pub fn g_variant_get(value: *mut GVariant,
                         format_string: *const gchar, ...) -> ();
    pub fn g_variant_new_va(format_string: *const gchar,
                            endptr: *mut *const gchar, app: *mut va_list)
     -> *mut GVariant;
    pub fn g_variant_get_va(value: *mut GVariant, format_string: *const gchar,
                            endptr: *mut *const gchar, app: *mut va_list)
     -> ();
    pub fn g_variant_check_format_string(value: *mut GVariant,
                                         format_string: *const gchar,
                                         copy_only: gboolean) -> gboolean;
    pub fn g_variant_parse(_type: *const GVariantType, text: *const gchar,
                           limit: *const gchar, endptr: *mut *const gchar,
                           error: *mut *mut GError) -> *mut GVariant;
    pub fn g_variant_new_parsed(format: *const gchar, ...) -> *mut GVariant;
    pub fn g_variant_new_parsed_va(format: *const gchar, app: *mut va_list)
     -> *mut GVariant;
    pub fn g_variant_parse_error_print_context(error: *mut GError,
                                               source_str: *const gchar)
     -> *mut gchar;
    pub fn g_variant_compare(one: gconstpointer, two: gconstpointer) -> gint;
    pub fn g_variant_dict_new(from_asv: *mut GVariant) -> *mut GVariantDict;
    pub fn g_variant_dict_init(dict: *mut GVariantDict,
                               from_asv: *mut GVariant) -> ();
    pub fn g_variant_dict_lookup(dict: *mut GVariantDict, key: *const gchar,
                                 format_string: *const gchar, ...)
     -> gboolean;
    pub fn g_variant_dict_lookup_value(dict: *mut GVariantDict,
                                       key: *const gchar,
                                       expected_type: *const GVariantType)
     -> *mut GVariant;
    pub fn g_variant_dict_contains(dict: *mut GVariantDict, key: *const gchar)
     -> gboolean;
    pub fn g_variant_dict_insert(dict: *mut GVariantDict, key: *const gchar,
                                 format_string: *const gchar, ...) -> ();
    pub fn g_variant_dict_insert_value(dict: *mut GVariantDict,
                                       key: *const gchar,
                                       value: *mut GVariant) -> ();
    pub fn g_variant_dict_remove(dict: *mut GVariantDict, key: *const gchar)
     -> gboolean;
    pub fn g_variant_dict_clear(dict: *mut GVariantDict) -> ();
    pub fn g_variant_dict_end(dict: *mut GVariantDict) -> *mut GVariant;
    pub fn g_variant_dict_ref(dict: *mut GVariantDict) -> *mut GVariantDict;
    pub fn g_variant_dict_unref(dict: *mut GVariantDict) -> ();
    pub fn glib_check_version(required_major: guint, required_minor: guint,
                              required_micro: guint) -> *const gchar;
    pub fn g_mem_chunk_new(name: *const gchar, atom_size: gint,
                           area_size: gsize, _type: gint) -> *mut GMemChunk;
    pub fn g_mem_chunk_destroy(mem_chunk: *mut GMemChunk) -> ();
    pub fn g_mem_chunk_alloc(mem_chunk: *mut GMemChunk) -> gpointer;
    pub fn g_mem_chunk_alloc0(mem_chunk: *mut GMemChunk) -> gpointer;
    pub fn g_mem_chunk_free(mem_chunk: *mut GMemChunk, mem: gpointer) -> ();
    pub fn g_mem_chunk_clean(mem_chunk: *mut GMemChunk) -> ();
    pub fn g_mem_chunk_reset(mem_chunk: *mut GMemChunk) -> ();
    pub fn g_mem_chunk_print(mem_chunk: *mut GMemChunk) -> ();
    pub fn g_mem_chunk_info() -> ();
    pub fn g_blow_chunks() -> ();
    pub fn g_allocator_new(name: *const gchar, n_preallocs: guint)
     -> *mut GAllocator;
    pub fn g_allocator_free(allocator: *mut GAllocator) -> ();
    pub fn g_list_push_allocator(allocator: *mut GAllocator) -> ();
    pub fn g_list_pop_allocator() -> ();
    pub fn g_slist_push_allocator(allocator: *mut GAllocator) -> ();
    pub fn g_slist_pop_allocator() -> ();
    pub fn g_node_push_allocator(allocator: *mut GAllocator) -> ();
    pub fn g_node_pop_allocator() -> ();
    pub fn g_cache_new(value_new_func: GCacheNewFunc,
                       value_destroy_func: GCacheDestroyFunc,
                       key_dup_func: GCacheDupFunc,
                       key_destroy_func: GCacheDestroyFunc,
                       hash_key_func: GHashFunc, hash_value_func: GHashFunc,
                       key_equal_func: GEqualFunc) -> *mut GCache;
    pub fn g_cache_destroy(cache: *mut GCache) -> ();
    pub fn g_cache_insert(cache: *mut GCache, key: gpointer) -> gpointer;
    pub fn g_cache_remove(cache: *mut GCache, value: gconstpointer) -> ();
    pub fn g_cache_key_foreach(cache: *mut GCache, func: GHFunc,
                               user_data: gpointer) -> ();
    pub fn g_cache_value_foreach(cache: *mut GCache, func: GHFunc,
                                 user_data: gpointer) -> ();
    pub fn g_completion_new(func: GCompletionFunc) -> *mut GCompletion;
    pub fn g_completion_add_items(cmp: *mut GCompletion, items: *mut GList)
     -> ();
    pub fn g_completion_remove_items(cmp: *mut GCompletion, items: *mut GList)
     -> ();
    pub fn g_completion_clear_items(cmp: *mut GCompletion) -> ();
    pub fn g_completion_complete(cmp: *mut GCompletion, prefix: *const gchar,
                                 new_prefix: *mut *mut gchar) -> *mut GList;
    pub fn g_completion_complete_utf8(cmp: *mut GCompletion,
                                      prefix: *const gchar,
                                      new_prefix: *mut *mut gchar)
     -> *mut GList;
    pub fn g_completion_set_compare(cmp: *mut GCompletion,
                                    strncmp_func: GCompletionStrncmpFunc)
     -> ();
    pub fn g_completion_free(cmp: *mut GCompletion) -> ();
    pub fn g_relation_new(fields: gint) -> *mut GRelation;
    pub fn g_relation_destroy(relation: *mut GRelation) -> ();
    pub fn g_relation_index(relation: *mut GRelation, field: gint,
                            hash_func: GHashFunc, key_equal_func: GEqualFunc)
     -> ();
    pub fn g_relation_insert(relation: *mut GRelation, ...) -> ();
    pub fn g_relation_delete(relation: *mut GRelation, key: gconstpointer,
                             field: gint) -> gint;
    pub fn g_relation_select(relation: *mut GRelation, key: gconstpointer,
                             field: gint) -> *mut GTuples;
    pub fn g_relation_count(relation: *mut GRelation, key: gconstpointer,
                            field: gint) -> gint;
    pub fn g_relation_exists(relation: *mut GRelation, ...) -> gboolean;
    pub fn g_relation_print(relation: *mut GRelation) -> ();
    pub fn g_tuples_destroy(tuples: *mut GTuples) -> ();
    pub fn g_tuples_index(tuples: *mut GTuples, index_: gint, field: gint)
     -> gpointer;
    pub fn g_thread_create(func: GThreadFunc, data: gpointer,
                           joinable: gboolean, error: *mut *mut GError)
     -> *mut GThread;
    pub fn g_thread_create_full(func: GThreadFunc, data: gpointer,
                                stack_size: gulong, joinable: gboolean,
                                bound: gboolean, priority: GThreadPriority,
                                error: *mut *mut GError) -> *mut GThread;
    pub fn g_thread_set_priority(thread: *mut GThread,
                                 priority: GThreadPriority) -> ();
    pub fn g_thread_foreach(thread_func: GFunc, user_data: gpointer) -> ();
    pub fn select(__nfds: ::libc::c_int, __readfds: *mut fd_set,
                  __writefds: *mut fd_set, __exceptfds: *mut fd_set,
                  __timeout: *mut Struct_timeval) -> ::libc::c_int;
    pub fn pselect(__nfds: ::libc::c_int, __readfds: *mut fd_set,
                   __writefds: *mut fd_set, __exceptfds: *mut fd_set,
                   __timeout: *const Struct_timespec,
                   __sigmask: *const __sigset_t) -> ::libc::c_int;
    pub fn gnu_dev_major(__dev: ::libc::c_ulonglong) -> ::libc::c_uint;
    pub fn gnu_dev_minor(__dev: ::libc::c_ulonglong) -> ::libc::c_uint;
    pub fn gnu_dev_makedev(__major: ::libc::c_uint, __minor: ::libc::c_uint)
     -> ::libc::c_ulonglong;
    pub fn __sched_cpucount(__setsize: size_t, __setp: *const cpu_set_t)
     -> ::libc::c_int;
    pub fn __sched_cpualloc(__count: size_t) -> *mut cpu_set_t;
    pub fn __sched_cpufree(__set: *mut cpu_set_t) -> ();
    pub fn sched_setparam(__pid: __pid_t, __param: *const Struct_sched_param)
     -> ::libc::c_int;
    pub fn sched_getparam(__pid: __pid_t, __param: *mut Struct_sched_param)
     -> ::libc::c_int;
    pub fn sched_setscheduler(__pid: __pid_t, __policy: ::libc::c_int,
                              __param: *const Struct_sched_param)
     -> ::libc::c_int;
    pub fn sched_getscheduler(__pid: __pid_t) -> ::libc::c_int;
    pub fn sched_yield() -> ::libc::c_int;
    pub fn sched_get_priority_max(__algorithm: ::libc::c_int)
     -> ::libc::c_int;
    pub fn sched_get_priority_min(__algorithm: ::libc::c_int)
     -> ::libc::c_int;
    pub fn sched_rr_get_interval(__pid: __pid_t, __t: *mut Struct_timespec)
     -> ::libc::c_int;
    pub fn pthread_create(__newthread: *mut pthread_t,
                          __attr: *const pthread_attr_t,
                          __start_routine:
                              ::std::option::Option<extern "C" fn(arg1:
                                                                      *mut ::libc::c_void)
                                                        ->
                                                            *mut ::libc::c_void>,
                          __arg: *mut ::libc::c_void) -> ::libc::c_int;
    pub fn pthread_exit(__retval: *mut ::libc::c_void) -> ();
    pub fn pthread_join(__th: pthread_t,
                        __thread_return: *mut *mut ::libc::c_void)
     -> ::libc::c_int;
    pub fn pthread_detach(__th: pthread_t) -> ::libc::c_int;
    pub fn pthread_self() -> pthread_t;
    pub fn pthread_equal(__thread1: pthread_t, __thread2: pthread_t)
     -> ::libc::c_int;
    pub fn pthread_attr_init(__attr: *mut pthread_attr_t) -> ::libc::c_int;
    pub fn pthread_attr_destroy(__attr: *mut pthread_attr_t) -> ::libc::c_int;
    pub fn pthread_attr_getdetachstate(__attr: *const pthread_attr_t,
                                       __detachstate: *mut ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_attr_setdetachstate(__attr: *mut pthread_attr_t,
                                       __detachstate: ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_attr_getguardsize(__attr: *const pthread_attr_t,
                                     __guardsize: *mut size_t)
     -> ::libc::c_int;
    pub fn pthread_attr_setguardsize(__attr: *mut pthread_attr_t,
                                     __guardsize: size_t) -> ::libc::c_int;
    pub fn pthread_attr_getschedparam(__attr: *const pthread_attr_t,
                                      __param: *mut Struct_sched_param)
     -> ::libc::c_int;
    pub fn pthread_attr_setschedparam(__attr: *mut pthread_attr_t,
                                      __param: *const Struct_sched_param)
     -> ::libc::c_int;
    pub fn pthread_attr_getschedpolicy(__attr: *const pthread_attr_t,
                                       __policy: *mut ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_attr_setschedpolicy(__attr: *mut pthread_attr_t,
                                       __policy: ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_attr_getinheritsched(__attr: *const pthread_attr_t,
                                        __inherit: *mut ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_attr_setinheritsched(__attr: *mut pthread_attr_t,
                                        __inherit: ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_attr_getscope(__attr: *const pthread_attr_t,
                                 __scope: *mut ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_attr_setscope(__attr: *mut pthread_attr_t,
                                 __scope: ::libc::c_int) -> ::libc::c_int;
    pub fn pthread_attr_getstackaddr(__attr: *const pthread_attr_t,
                                     __stackaddr: *mut *mut ::libc::c_void)
     -> ::libc::c_int;
    pub fn pthread_attr_setstackaddr(__attr: *mut pthread_attr_t,
                                     __stackaddr: *mut ::libc::c_void)
     -> ::libc::c_int;
    pub fn pthread_attr_getstacksize(__attr: *const pthread_attr_t,
                                     __stacksize: *mut size_t)
     -> ::libc::c_int;
    pub fn pthread_attr_setstacksize(__attr: *mut pthread_attr_t,
                                     __stacksize: size_t) -> ::libc::c_int;
    pub fn pthread_attr_getstack(__attr: *const pthread_attr_t,
                                 __stackaddr: *mut *mut ::libc::c_void,
                                 __stacksize: *mut size_t) -> ::libc::c_int;
    pub fn pthread_attr_setstack(__attr: *mut pthread_attr_t,
                                 __stackaddr: *mut ::libc::c_void,
                                 __stacksize: size_t) -> ::libc::c_int;
    pub fn pthread_setschedparam(__target_thread: pthread_t,
                                 __policy: ::libc::c_int,
                                 __param: *const Struct_sched_param)
     -> ::libc::c_int;
    pub fn pthread_getschedparam(__target_thread: pthread_t,
                                 __policy: *mut ::libc::c_int,
                                 __param: *mut Struct_sched_param)
     -> ::libc::c_int;
    pub fn pthread_setschedprio(__target_thread: pthread_t,
                                __prio: ::libc::c_int) -> ::libc::c_int;
    pub fn pthread_once(__once_control: *mut pthread_once_t,
                        __init_routine:
                            ::std::option::Option<extern "C" fn() -> ()>)
     -> ::libc::c_int;
    pub fn pthread_setcancelstate(__state: ::libc::c_int,
                                  __oldstate: *mut ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_setcanceltype(__type: ::libc::c_int,
                                 __oldtype: *mut ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_cancel(__th: pthread_t) -> ::libc::c_int;
    pub fn pthread_testcancel() -> ();
    pub fn __pthread_register_cancel(__buf: *mut __pthread_unwind_buf_t)
     -> ();
    pub fn __pthread_unregister_cancel(__buf: *mut __pthread_unwind_buf_t)
     -> ();
    pub fn __pthread_unwind_next(__buf: *mut __pthread_unwind_buf_t) -> ();
    pub fn __sigsetjmp(__env: *mut Struct___jmp_buf_tag,
                       __savemask: ::libc::c_int) -> ::libc::c_int;
    pub fn pthread_mutex_init(__mutex: *mut pthread_mutex_t,
                              __mutexattr: *const pthread_mutexattr_t)
     -> ::libc::c_int;
    pub fn pthread_mutex_destroy(__mutex: *mut pthread_mutex_t)
     -> ::libc::c_int;
    pub fn pthread_mutex_trylock(__mutex: *mut pthread_mutex_t)
     -> ::libc::c_int;
    pub fn pthread_mutex_lock(__mutex: *mut pthread_mutex_t) -> ::libc::c_int;
    pub fn pthread_mutex_timedlock(__mutex: *mut pthread_mutex_t,
                                   __abstime: *const Struct_timespec)
     -> ::libc::c_int;
    pub fn pthread_mutex_unlock(__mutex: *mut pthread_mutex_t)
     -> ::libc::c_int;
    pub fn pthread_mutex_getprioceiling(__mutex: *const pthread_mutex_t,
                                        __prioceiling: *mut ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_mutex_setprioceiling(__mutex: *mut pthread_mutex_t,
                                        __prioceiling: ::libc::c_int,
                                        __old_ceiling: *mut ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_mutex_consistent(__mutex: *mut pthread_mutex_t)
     -> ::libc::c_int;
    pub fn pthread_mutexattr_init(__attr: *mut pthread_mutexattr_t)
     -> ::libc::c_int;
    pub fn pthread_mutexattr_destroy(__attr: *mut pthread_mutexattr_t)
     -> ::libc::c_int;
    pub fn pthread_mutexattr_getpshared(__attr: *const pthread_mutexattr_t,
                                        __pshared: *mut ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_mutexattr_setpshared(__attr: *mut pthread_mutexattr_t,
                                        __pshared: ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_mutexattr_gettype(__attr: *const pthread_mutexattr_t,
                                     __kind: *mut ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_mutexattr_settype(__attr: *mut pthread_mutexattr_t,
                                     __kind: ::libc::c_int) -> ::libc::c_int;
    pub fn pthread_mutexattr_getprotocol(__attr: *const pthread_mutexattr_t,
                                         __protocol: *mut ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_mutexattr_setprotocol(__attr: *mut pthread_mutexattr_t,
                                         __protocol: ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_mutexattr_getprioceiling(__attr:
                                                *const pthread_mutexattr_t,
                                            __prioceiling: *mut ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_mutexattr_setprioceiling(__attr: *mut pthread_mutexattr_t,
                                            __prioceiling: ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_mutexattr_getrobust(__attr: *const pthread_mutexattr_t,
                                       __robustness: *mut ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_mutexattr_setrobust(__attr: *mut pthread_mutexattr_t,
                                       __robustness: ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_rwlock_init(__rwlock: *mut pthread_rwlock_t,
                               __attr: *const pthread_rwlockattr_t)
     -> ::libc::c_int;
    pub fn pthread_rwlock_destroy(__rwlock: *mut pthread_rwlock_t)
     -> ::libc::c_int;
    pub fn pthread_rwlock_rdlock(__rwlock: *mut pthread_rwlock_t)
     -> ::libc::c_int;
    pub fn pthread_rwlock_tryrdlock(__rwlock: *mut pthread_rwlock_t)
     -> ::libc::c_int;
    pub fn pthread_rwlock_timedrdlock(__rwlock: *mut pthread_rwlock_t,
                                      __abstime: *const Struct_timespec)
     -> ::libc::c_int;
    pub fn pthread_rwlock_wrlock(__rwlock: *mut pthread_rwlock_t)
     -> ::libc::c_int;
    pub fn pthread_rwlock_trywrlock(__rwlock: *mut pthread_rwlock_t)
     -> ::libc::c_int;
    pub fn pthread_rwlock_timedwrlock(__rwlock: *mut pthread_rwlock_t,
                                      __abstime: *const Struct_timespec)
     -> ::libc::c_int;
    pub fn pthread_rwlock_unlock(__rwlock: *mut pthread_rwlock_t)
     -> ::libc::c_int;
    pub fn pthread_rwlockattr_init(__attr: *mut pthread_rwlockattr_t)
     -> ::libc::c_int;
    pub fn pthread_rwlockattr_destroy(__attr: *mut pthread_rwlockattr_t)
     -> ::libc::c_int;
    pub fn pthread_rwlockattr_getpshared(__attr: *const pthread_rwlockattr_t,
                                         __pshared: *mut ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_rwlockattr_setpshared(__attr: *mut pthread_rwlockattr_t,
                                         __pshared: ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_rwlockattr_getkind_np(__attr: *const pthread_rwlockattr_t,
                                         __pref: *mut ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_rwlockattr_setkind_np(__attr: *mut pthread_rwlockattr_t,
                                         __pref: ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_cond_init(__cond: *mut pthread_cond_t,
                             __cond_attr: *const pthread_condattr_t)
     -> ::libc::c_int;
    pub fn pthread_cond_destroy(__cond: *mut pthread_cond_t) -> ::libc::c_int;
    pub fn pthread_cond_signal(__cond: *mut pthread_cond_t) -> ::libc::c_int;
    pub fn pthread_cond_broadcast(__cond: *mut pthread_cond_t)
     -> ::libc::c_int;
    pub fn pthread_cond_wait(__cond: *mut pthread_cond_t,
                             __mutex: *mut pthread_mutex_t) -> ::libc::c_int;
    pub fn pthread_cond_timedwait(__cond: *mut pthread_cond_t,
                                  __mutex: *mut pthread_mutex_t,
                                  __abstime: *const Struct_timespec)
     -> ::libc::c_int;
    pub fn pthread_condattr_init(__attr: *mut pthread_condattr_t)
     -> ::libc::c_int;
    pub fn pthread_condattr_destroy(__attr: *mut pthread_condattr_t)
     -> ::libc::c_int;
    pub fn pthread_condattr_getpshared(__attr: *const pthread_condattr_t,
                                       __pshared: *mut ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_condattr_setpshared(__attr: *mut pthread_condattr_t,
                                       __pshared: ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_condattr_getclock(__attr: *const pthread_condattr_t,
                                     __clock_id: *mut __clockid_t)
     -> ::libc::c_int;
    pub fn pthread_condattr_setclock(__attr: *mut pthread_condattr_t,
                                     __clock_id: __clockid_t)
     -> ::libc::c_int;
    pub fn pthread_spin_init(__lock: *mut pthread_spinlock_t,
                             __pshared: ::libc::c_int) -> ::libc::c_int;
    pub fn pthread_spin_destroy(__lock: *mut pthread_spinlock_t)
     -> ::libc::c_int;
    pub fn pthread_spin_lock(__lock: *mut pthread_spinlock_t)
     -> ::libc::c_int;
    pub fn pthread_spin_trylock(__lock: *mut pthread_spinlock_t)
     -> ::libc::c_int;
    pub fn pthread_spin_unlock(__lock: *mut pthread_spinlock_t)
     -> ::libc::c_int;
    pub fn pthread_barrier_init(__barrier: *mut pthread_barrier_t,
                                __attr: *const pthread_barrierattr_t,
                                __count: ::libc::c_uint) -> ::libc::c_int;
    pub fn pthread_barrier_destroy(__barrier: *mut pthread_barrier_t)
     -> ::libc::c_int;
    pub fn pthread_barrier_wait(__barrier: *mut pthread_barrier_t)
     -> ::libc::c_int;
    pub fn pthread_barrierattr_init(__attr: *mut pthread_barrierattr_t)
     -> ::libc::c_int;
    pub fn pthread_barrierattr_destroy(__attr: *mut pthread_barrierattr_t)
     -> ::libc::c_int;
    pub fn pthread_barrierattr_getpshared(__attr:
                                              *const pthread_barrierattr_t,
                                          __pshared: *mut ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_barrierattr_setpshared(__attr: *mut pthread_barrierattr_t,
                                          __pshared: ::libc::c_int)
     -> ::libc::c_int;
    pub fn pthread_key_create(__key: *mut pthread_key_t,
                              __destr_function:
                                  ::std::option::Option<extern "C" fn(arg1:
                                                                          *mut ::libc::c_void)
                                                            -> ()>)
     -> ::libc::c_int;
    pub fn pthread_key_delete(__key: pthread_key_t) -> ::libc::c_int;
    pub fn pthread_getspecific(__key: pthread_key_t) -> *mut ::libc::c_void;
    pub fn pthread_setspecific(__key: pthread_key_t,
                               __pointer: *const ::libc::c_void)
     -> ::libc::c_int;
    pub fn pthread_getcpuclockid(__thread_id: pthread_t,
                                 __clock_id: *mut __clockid_t)
     -> ::libc::c_int;
    pub fn pthread_atfork(__prepare:
                              ::std::option::Option<extern "C" fn() -> ()>,
                          __parent:
                              ::std::option::Option<extern "C" fn() -> ()>,
                          __child:
                              ::std::option::Option<extern "C" fn() -> ()>)
     -> ::libc::c_int;
    pub fn g_static_mutex_init(mutex: *mut GStaticMutex) -> ();
    pub fn g_static_mutex_free(mutex: *mut GStaticMutex) -> ();
    pub fn g_static_mutex_get_mutex_impl(mutex: *mut GStaticMutex)
     -> *mut GMutex;
    pub fn g_static_rec_mutex_init(mutex: *mut GStaticRecMutex) -> ();
    pub fn g_static_rec_mutex_lock(mutex: *mut GStaticRecMutex) -> ();
    pub fn g_static_rec_mutex_trylock(mutex: *mut GStaticRecMutex)
     -> gboolean;
    pub fn g_static_rec_mutex_unlock(mutex: *mut GStaticRecMutex) -> ();
    pub fn g_static_rec_mutex_lock_full(mutex: *mut GStaticRecMutex,
                                        depth: guint) -> ();
    pub fn g_static_rec_mutex_unlock_full(mutex: *mut GStaticRecMutex)
     -> guint;
    pub fn g_static_rec_mutex_free(mutex: *mut GStaticRecMutex) -> ();
    pub fn g_static_rw_lock_init(lock: *mut GStaticRWLock) -> ();
    pub fn g_static_rw_lock_reader_lock(lock: *mut GStaticRWLock) -> ();
    pub fn g_static_rw_lock_reader_trylock(lock: *mut GStaticRWLock)
     -> gboolean;
    pub fn g_static_rw_lock_reader_unlock(lock: *mut GStaticRWLock) -> ();
    pub fn g_static_rw_lock_writer_lock(lock: *mut GStaticRWLock) -> ();
    pub fn g_static_rw_lock_writer_trylock(lock: *mut GStaticRWLock)
     -> gboolean;
    pub fn g_static_rw_lock_writer_unlock(lock: *mut GStaticRWLock) -> ();
    pub fn g_static_rw_lock_free(lock: *mut GStaticRWLock) -> ();
    pub fn g_private_new(notify: GDestroyNotify) -> *mut GPrivate;
    pub fn g_static_private_init(private_key: *mut GStaticPrivate) -> ();
    pub fn g_static_private_get(private_key: *mut GStaticPrivate) -> gpointer;
    pub fn g_static_private_set(private_key: *mut GStaticPrivate,
                                data: gpointer, notify: GDestroyNotify) -> ();
    pub fn g_static_private_free(private_key: *mut GStaticPrivate) -> ();
    pub fn g_once_init_enter_impl(location: *mut gsize) -> gboolean;
    pub fn g_thread_init(vtable: gpointer) -> ();
    pub fn g_thread_init_with_errorcheck_mutexes(vtable: gpointer) -> ();
    pub fn g_thread_get_initialized() -> gboolean;
    pub fn g_mutex_new() -> *mut GMutex;
    pub fn g_mutex_free(mutex: *mut GMutex) -> ();
    pub fn g_cond_new() -> *mut GCond;
    pub fn g_cond_free(cond: *mut GCond) -> ();
    pub fn g_cond_timed_wait(cond: *mut GCond, mutex: *mut GMutex,
                             timeval: *mut GTimeVal) -> gboolean;
    pub fn cfg_args_validate(_self: *mut CfgArgs, defs: *mut CfgArgs,
                             context: *const gchar) -> gboolean;
    pub fn cfg_args_set(_self: *mut CfgArgs, name: *const gchar,
                        value: *const gchar) -> ();
    pub fn cfg_args_get(_self: *mut CfgArgs, name: *const gchar)
     -> *const gchar;
    pub fn cfg_args_foreach(_self: *mut CfgArgs, func: GHFunc,
                            user_data: gpointer) -> ();
    pub fn cfg_args_new() -> *mut CfgArgs;
    pub fn cfg_args_ref(_self: *mut CfgArgs) -> *mut CfgArgs;
    pub fn cfg_args_unref(_self: *mut CfgArgs) -> ();
    pub fn __underflow(arg1: *mut _IO_FILE) -> ::libc::c_int;
    pub fn __uflow(arg1: *mut _IO_FILE) -> ::libc::c_int;
    pub fn __overflow(arg1: *mut _IO_FILE, arg2: ::libc::c_int)
     -> ::libc::c_int;
    pub fn _IO_getc(__fp: *mut _IO_FILE) -> ::libc::c_int;
    pub fn _IO_putc(__c: ::libc::c_int, __fp: *mut _IO_FILE) -> ::libc::c_int;
    pub fn _IO_feof(__fp: *mut _IO_FILE) -> ::libc::c_int;
    pub fn _IO_ferror(__fp: *mut _IO_FILE) -> ::libc::c_int;
    pub fn _IO_peekc_locked(__fp: *mut _IO_FILE) -> ::libc::c_int;
    pub fn _IO_flockfile(arg1: *mut _IO_FILE) -> ();
    pub fn _IO_funlockfile(arg1: *mut _IO_FILE) -> ();
    pub fn _IO_ftrylockfile(arg1: *mut _IO_FILE) -> ::libc::c_int;
    pub fn _IO_vfscanf(arg1: *mut _IO_FILE, arg2: *const ::libc::c_char,
                       arg3: __gnuc_va_list, arg4: *mut ::libc::c_int)
     -> ::libc::c_int;
    pub fn _IO_vfprintf(arg1: *mut _IO_FILE, arg2: *const ::libc::c_char,
                        arg3: __gnuc_va_list) -> ::libc::c_int;
    pub fn _IO_padn(arg1: *mut _IO_FILE, arg2: ::libc::c_int, arg3: __ssize_t)
     -> __ssize_t;
    pub fn _IO_sgetn(arg1: *mut _IO_FILE, arg2: *mut ::libc::c_void,
                     arg3: size_t) -> size_t;
    pub fn _IO_seekoff(arg1: *mut _IO_FILE, arg2: __off64_t,
                       arg3: ::libc::c_int, arg4: ::libc::c_int) -> __off64_t;
    pub fn _IO_seekpos(arg1: *mut _IO_FILE, arg2: __off64_t,
                       arg3: ::libc::c_int) -> __off64_t;
    pub fn _IO_free_backup_area(arg1: *mut _IO_FILE) -> ();
    pub fn remove(__filename: *const ::libc::c_char) -> ::libc::c_int;
    pub fn rename(__old: *const ::libc::c_char, __new: *const ::libc::c_char)
     -> ::libc::c_int;
    pub fn renameat(__oldfd: ::libc::c_int, __old: *const ::libc::c_char,
                    __newfd: ::libc::c_int, __new: *const ::libc::c_char)
     -> ::libc::c_int;
    pub fn tmpfile() -> *mut FILE;
    pub fn tmpnam(__s: *mut ::libc::c_char) -> *mut ::libc::c_char;
    pub fn tmpnam_r(__s: *mut ::libc::c_char) -> *mut ::libc::c_char;
    pub fn tempnam(__dir: *const ::libc::c_char, __pfx: *const ::libc::c_char)
     -> *mut ::libc::c_char;
    pub fn fclose(__stream: *mut FILE) -> ::libc::c_int;
    pub fn fflush(__stream: *mut FILE) -> ::libc::c_int;
    pub fn fflush_unlocked(__stream: *mut FILE) -> ::libc::c_int;
    pub fn fopen(__filename: *const ::libc::c_char,
                 __modes: *const ::libc::c_char) -> *mut FILE;
    pub fn freopen(__filename: *const ::libc::c_char,
                   __modes: *const ::libc::c_char, __stream: *mut FILE)
     -> *mut FILE;
    pub fn fdopen(__fd: ::libc::c_int, __modes: *const ::libc::c_char)
     -> *mut FILE;
    pub fn fmemopen(__s: *mut ::libc::c_void, __len: size_t,
                    __modes: *const ::libc::c_char) -> *mut FILE;
    pub fn open_memstream(__bufloc: *mut *mut ::libc::c_char,
                          __sizeloc: *mut size_t) -> *mut FILE;
    pub fn setbuf(__stream: *mut FILE, __buf: *mut ::libc::c_char) -> ();
    pub fn setvbuf(__stream: *mut FILE, __buf: *mut ::libc::c_char,
                   __modes: ::libc::c_int, __n: size_t) -> ::libc::c_int;
    pub fn setbuffer(__stream: *mut FILE, __buf: *mut ::libc::c_char,
                     __size: size_t) -> ();
    pub fn setlinebuf(__stream: *mut FILE) -> ();
    pub fn fprintf(__stream: *mut FILE, __format: *const ::libc::c_char, ...)
     -> ::libc::c_int;
    pub fn printf(__format: *const ::libc::c_char, ...) -> ::libc::c_int;
    pub fn sprintf(__s: *mut ::libc::c_char,
                   __format: *const ::libc::c_char, ...) -> ::libc::c_int;
    pub fn vfprintf(__s: *mut FILE, __format: *const ::libc::c_char,
                    __arg: __gnuc_va_list) -> ::libc::c_int;
    pub fn vprintf(__format: *const ::libc::c_char, __arg: __gnuc_va_list)
     -> ::libc::c_int;
    pub fn vsprintf(__s: *mut ::libc::c_char, __format: *const ::libc::c_char,
                    __arg: __gnuc_va_list) -> ::libc::c_int;
    pub fn snprintf(__s: *mut ::libc::c_char, __maxlen: size_t,
                    __format: *const ::libc::c_char, ...) -> ::libc::c_int;
    pub fn vsnprintf(__s: *mut ::libc::c_char, __maxlen: size_t,
                     __format: *const ::libc::c_char, __arg: __gnuc_va_list)
     -> ::libc::c_int;
    pub fn vdprintf(__fd: ::libc::c_int, __fmt: *const ::libc::c_char,
                    __arg: __gnuc_va_list) -> ::libc::c_int;
    pub fn dprintf(__fd: ::libc::c_int, __fmt: *const ::libc::c_char, ...)
     -> ::libc::c_int;
    pub fn fscanf(__stream: *mut FILE, __format: *const ::libc::c_char, ...)
     -> ::libc::c_int;
    pub fn scanf(__format: *const ::libc::c_char, ...) -> ::libc::c_int;
    pub fn sscanf(__s: *const ::libc::c_char,
                  __format: *const ::libc::c_char, ...) -> ::libc::c_int;
    pub fn vfscanf(__s: *mut FILE, __format: *const ::libc::c_char,
                   __arg: __gnuc_va_list) -> ::libc::c_int;
    pub fn vscanf(__format: *const ::libc::c_char, __arg: __gnuc_va_list)
     -> ::libc::c_int;
    pub fn vsscanf(__s: *const ::libc::c_char,
                   __format: *const ::libc::c_char, __arg: __gnuc_va_list)
     -> ::libc::c_int;
    pub fn fgetc(__stream: *mut FILE) -> ::libc::c_int;
    pub fn getc(__stream: *mut FILE) -> ::libc::c_int;
    pub fn getchar() -> ::libc::c_int;
    pub fn getc_unlocked(__stream: *mut FILE) -> ::libc::c_int;
    pub fn getchar_unlocked() -> ::libc::c_int;
    pub fn fgetc_unlocked(__stream: *mut FILE) -> ::libc::c_int;
    pub fn fputc(__c: ::libc::c_int, __stream: *mut FILE) -> ::libc::c_int;
    pub fn putc(__c: ::libc::c_int, __stream: *mut FILE) -> ::libc::c_int;
    pub fn putchar(__c: ::libc::c_int) -> ::libc::c_int;
    pub fn fputc_unlocked(__c: ::libc::c_int, __stream: *mut FILE)
     -> ::libc::c_int;
    pub fn putc_unlocked(__c: ::libc::c_int, __stream: *mut FILE)
     -> ::libc::c_int;
    pub fn putchar_unlocked(__c: ::libc::c_int) -> ::libc::c_int;
    pub fn getw(__stream: *mut FILE) -> ::libc::c_int;
    pub fn putw(__w: ::libc::c_int, __stream: *mut FILE) -> ::libc::c_int;
    pub fn fgets(__s: *mut ::libc::c_char, __n: ::libc::c_int,
                 __stream: *mut FILE) -> *mut ::libc::c_char;
    pub fn gets(__s: *mut ::libc::c_char) -> *mut ::libc::c_char;
    pub fn __getdelim(__lineptr: *mut *mut ::libc::c_char, __n: *mut size_t,
                      __delimiter: ::libc::c_int, __stream: *mut FILE)
     -> __ssize_t;
    pub fn getdelim(__lineptr: *mut *mut ::libc::c_char, __n: *mut size_t,
                    __delimiter: ::libc::c_int, __stream: *mut FILE)
     -> __ssize_t;
    pub fn getline(__lineptr: *mut *mut ::libc::c_char, __n: *mut size_t,
                   __stream: *mut FILE) -> __ssize_t;
    pub fn fputs(__s: *const ::libc::c_char, __stream: *mut FILE)
     -> ::libc::c_int;
    pub fn puts(__s: *const ::libc::c_char) -> ::libc::c_int;
    pub fn ungetc(__c: ::libc::c_int, __stream: *mut FILE) -> ::libc::c_int;
    pub fn fread(__ptr: *mut ::libc::c_void, __size: size_t, __n: size_t,
                 __stream: *mut FILE) -> size_t;
    pub fn fwrite(__ptr: *const ::libc::c_void, __size: size_t, __n: size_t,
                  __s: *mut FILE) -> size_t;
    pub fn fread_unlocked(__ptr: *mut ::libc::c_void, __size: size_t,
                          __n: size_t, __stream: *mut FILE) -> size_t;
    pub fn fwrite_unlocked(__ptr: *const ::libc::c_void, __size: size_t,
                           __n: size_t, __stream: *mut FILE) -> size_t;
    pub fn fseek(__stream: *mut FILE, __off: ::libc::c_long,
                 __whence: ::libc::c_int) -> ::libc::c_int;
    pub fn ftell(__stream: *mut FILE) -> ::libc::c_long;
    pub fn rewind(__stream: *mut FILE) -> ();
    pub fn fseeko(__stream: *mut FILE, __off: __off_t,
                  __whence: ::libc::c_int) -> ::libc::c_int;
    pub fn ftello(__stream: *mut FILE) -> __off_t;
    pub fn fgetpos(__stream: *mut FILE, __pos: *mut fpos_t) -> ::libc::c_int;
    pub fn fsetpos(__stream: *mut FILE, __pos: *const fpos_t)
     -> ::libc::c_int;
    pub fn clearerr(__stream: *mut FILE) -> ();
    pub fn feof(__stream: *mut FILE) -> ::libc::c_int;
    pub fn ferror(__stream: *mut FILE) -> ::libc::c_int;
    pub fn clearerr_unlocked(__stream: *mut FILE) -> ();
    pub fn feof_unlocked(__stream: *mut FILE) -> ::libc::c_int;
    pub fn ferror_unlocked(__stream: *mut FILE) -> ::libc::c_int;
    pub fn perror(__s: *const ::libc::c_char) -> ();
    pub fn fileno(__stream: *mut FILE) -> ::libc::c_int;
    pub fn fileno_unlocked(__stream: *mut FILE) -> ::libc::c_int;
    pub fn popen(__command: *const ::libc::c_char,
                 __modes: *const ::libc::c_char) -> *mut FILE;
    pub fn pclose(__stream: *mut FILE) -> ::libc::c_int;
    pub fn ctermid(__s: *mut ::libc::c_char) -> *mut ::libc::c_char;
    pub fn flockfile(__stream: *mut FILE) -> ();
    pub fn ftrylockfile(__stream: *mut FILE) -> ::libc::c_int;
    pub fn funlockfile(__stream: *mut FILE) -> ();
    pub fn setjmp(__env: jmp_buf) -> ::libc::c_int;
    pub fn _setjmp(__env: *mut Struct___jmp_buf_tag) -> ::libc::c_int;
    pub fn longjmp(__env: *mut Struct___jmp_buf_tag, __val: ::libc::c_int)
     -> ();
    pub fn _longjmp(__env: *mut Struct___jmp_buf_tag, __val: ::libc::c_int)
     -> ();
    pub fn siglongjmp(__env: sigjmp_buf, __val: ::libc::c_int) -> ();
    pub fn cfg_lexer_subst_args(globals: *mut CfgArgs, defs: *mut CfgArgs,
                                args: *mut CfgArgs, input: *const gchar,
                                input_length: gssize,
                                output_length: *mut gsize,
                                error: *mut *mut GError) -> *mut gchar;
    pub fn cfg_lexer_unput_token(_self: *mut CfgLexer, yylval: *mut YYSTYPE)
     -> ();
    pub fn cfg_lexer_start_block_state(_self: *mut CfgLexer,
                                       block_boundary: *mut gchar) -> ();
    pub fn cfg_lexer_append_string(_self: *mut CfgLexer,
                                   length: ::libc::c_int,
                                   str: *mut ::libc::c_char) -> ();
    pub fn cfg_lexer_append_char(_self: *mut CfgLexer, c: ::libc::c_char)
     -> ();
    pub fn cfg_lexer_set_current_keywords(_self: *mut CfgLexer,
                                          keywords: *mut CfgLexerKeyword)
     -> ();
    pub fn cfg_lexer_get_keyword_string(_self: *mut CfgLexer,
                                        kw: ::libc::c_int)
     -> *mut ::libc::c_char;
    pub fn cfg_lexer_lookup_keyword(_self: *mut CfgLexer,
                                    yylval: *mut YYSTYPE,
                                    yylloc: *mut YYLTYPE,
                                    token: *const ::libc::c_char)
     -> ::libc::c_int;
    pub fn cfg_lexer_start_next_include(_self: *mut CfgLexer) -> gboolean;
    pub fn cfg_lexer_include_file(_self: *mut CfgLexer,
                                  filename: *const gchar) -> gboolean;
    pub fn cfg_lexer_include_buffer(_self: *mut CfgLexer, name: *const gchar,
                                    buffer: *const gchar, length: gssize)
     -> gboolean;
    pub fn cfg_lexer_push_context(_self: *mut CfgLexer, context: gint,
                                  keywords: *mut CfgLexerKeyword,
                                  desc: *const gchar) -> ();
    pub fn cfg_lexer_pop_context(_self: *mut CfgLexer) -> ();
    pub fn cfg_lexer_get_context_description(_self: *mut CfgLexer)
     -> *const gchar;
    pub fn cfg_lexer_get_context_type(_self: *mut CfgLexer) -> gint;
    pub fn cfg_lexer_inject_token_block(_self: *mut CfgLexer,
                                        block: *mut CfgTokenBlock) -> ();
    pub fn cfg_lexer_register_block_generator(_self: *mut CfgLexer,
                                              context: gint,
                                              name: *const gchar,
                                              generator:
                                                  CfgBlockGeneratorFunc,
                                              user_data: gpointer,
                                              user_data_free: GDestroyNotify)
     -> gboolean;
    pub fn cfg_lexer_lex(_self: *mut CfgLexer, yylval: *mut YYSTYPE,
                         yylloc: *mut YYLTYPE) -> ::libc::c_int;
    pub fn cfg_lexer_free_token(token: *mut YYSTYPE) -> ();
    pub fn cfg_lexer_new(file: *mut FILE, filename: *const gchar,
                         preprocess_output: *mut GString) -> *mut CfgLexer;
    pub fn cfg_lexer_new_buffer(buffer: *const gchar, length: gsize)
     -> *mut CfgLexer;
    pub fn cfg_lexer_free(_self: *mut CfgLexer) -> ();
    pub fn cfg_lexer_lookup_context_type_by_name(name: *const gchar) -> gint;
    pub fn cfg_lexer_lookup_context_name_by_type(id: gint) -> *const gchar;
    pub fn cfg_token_block_add_token(_self: *mut CfgTokenBlock,
                                     token: *mut YYSTYPE) -> ();
    pub fn cfg_token_block_get_token(_self: *mut CfgTokenBlock)
     -> *mut YYSTYPE;
    pub fn cfg_token_block_new() -> *mut CfgTokenBlock;
    pub fn cfg_token_block_free(_self: *mut CfgTokenBlock) -> ();
    pub fn cfg_block_generate(lexer: *mut CfgLexer, context: gint,
                              name: *const gchar, args: *mut CfgArgs,
                              user_data: gpointer) -> gboolean;
    pub fn cfg_block_new(content: *const gchar, arg_defs: *mut CfgArgs)
     -> *mut CfgBlock;
    pub fn cfg_block_free(_self: *mut CfgBlock) -> ();
    pub fn cfg_lexer_error_quark() -> GQuark;
    pub fn cfg_process_flag(handlers: *mut CfgFlagHandler, base: gpointer,
                            flag: *const gchar) -> gboolean;
    pub fn report_syntax_error(lexer: *mut CfgLexer, yylloc: *mut YYLTYPE,
                               what: *const ::libc::c_char,
                               msg: *const ::libc::c_char) -> ();
    pub fn main_lex(yylval: *mut YYSTYPE, yylloc: *mut YYLTYPE,
                    lexer: *mut CfgLexer) -> ::libc::c_int;
    pub fn main_error(yylloc: *mut YYLTYPE, lexer: *mut CfgLexer,
                      instance: *mut gpointer, arg: gpointer,
                      msg: *const ::libc::c_char) -> ();
    pub fn plugin_find(cfg: *mut GlobalConfig, plugin_type: gint,
                       plugin_name: *const gchar) -> *mut Plugin;
    pub fn plugin_construct(_self: *mut Plugin, cfg: *mut GlobalConfig,
                            plugin_type: gint, plugin_name: *const gchar)
     -> gpointer;
    pub fn plugin_parse_config(plugin: *mut Plugin, cfg: *mut GlobalConfig,
                               yylloc: *mut YYLTYPE, arg: gpointer)
     -> gpointer;
    pub fn plugin_register(cfg: *mut GlobalConfig, p: *mut Plugin,
                           number: gint) -> ();
    pub fn plugin_load_module(module_name: *const gchar,
                              cfg: *mut GlobalConfig, args: *mut CfgArgs)
     -> gboolean;
    pub fn plugin_list_modules(out: *mut FILE, verbose: gboolean) -> ();
    pub fn plugin_load_candidate_modules(cfg: *mut GlobalConfig) -> ();
    pub fn plugin_free_candidate_modules(cfg: *mut GlobalConfig) -> ();
    pub fn plugin_free_plugins(cfg: *mut GlobalConfig) -> ();
}