guile-sys 0.1.1

#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
/* automatically generated by rust-bindgen */

extern crate libc;
use libc::{
    c_long,
    c_longlong,
    c_double,
    c_ulong,
    c_void,
    c_int,
    c_char,
    c_ushort,
    c_uint,
    c_float,
    c_ulonglong,
    c_short,
    c_uchar
};

pub type ptrdiff_t = c_long;
pub type size_t = c_ulong;
pub type wchar_t = c_int;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed1 {
    pub __clang_max_align_nonce1: c_longlong,
    pub __clang_max_align_nonce2: c_double,
}
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 max_align_t = Struct_Unnamed1;
pub type mp_limb_t = c_ulong;
pub type mp_limb_signed_t = c_long;
pub type mp_bitcnt_t = c_ulong;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed2 {
    pub _mp_alloc: c_int,
    pub _mp_size: c_int,
    pub _mp_d: *mut mp_limb_t,
}
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() } }
}
pub type __mpz_struct = Struct_Unnamed2;
pub type MP_INT = __mpz_struct;
pub type mpz_t = [__mpz_struct; 1usize];
pub type mp_ptr = *mut mp_limb_t;
pub type mp_srcptr = *const mp_limb_t;
pub type mp_size_t = c_long;
pub type mp_exp_t = c_long;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed3 {
    pub _mp_num: __mpz_struct,
    pub _mp_den: __mpz_struct,
}
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 __mpq_struct = Struct_Unnamed3;
pub type MP_RAT = __mpq_struct;
pub type mpq_t = [__mpq_struct; 1usize];
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed4 {
    pub _mp_prec: c_int,
    pub _mp_size: c_int,
    pub _mp_exp: mp_exp_t,
    pub _mp_d: *mut mp_limb_t,
}
impl ::std::clone::Clone for Struct_Unnamed4 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed4 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type __mpf_struct = Struct_Unnamed4;
pub type mpf_t = [__mpf_struct; 1usize];
pub const GMP_RAND_ALG_LC: Enum_Unnamed5 =
    Enum_Unnamed5::GMP_RAND_ALG_DEFAULT;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed5 { GMP_RAND_ALG_DEFAULT = 0, }
pub type gmp_randalg_t = Enum_Unnamed5;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed6 {
    pub _mp_seed: mpz_t,
    pub _mp_alg: gmp_randalg_t,
    pub _mp_algdata: Union_Unnamed7,
}
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() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed7 {
    pub _bindgen_data_: [u64; 1usize],
}
impl Union_Unnamed7 {
    pub unsafe fn _mp_lc(&mut self) -> *mut *mut c_void {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed7 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed7 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type __gmp_randstate_struct = Struct_Unnamed6;
pub type gmp_randstate_t = [__gmp_randstate_struct; 1usize];
pub type mpz_srcptr = *const __mpz_struct;
pub type mpz_ptr = *mut __mpz_struct;
pub type mpf_srcptr = *const __mpf_struct;
pub type mpf_ptr = *mut __mpf_struct;
pub type mpq_srcptr = *const __mpq_struct;
pub type mpq_ptr = *mut __mpq_struct;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed8 {
    GMP_ERROR_NONE = 0,
    GMP_ERROR_UNSUPPORTED_ARGUMENT = 1,
    GMP_ERROR_DIVISION_BY_ZERO = 2,
    GMP_ERROR_SQRT_OF_NEGATIVE = 4,
    GMP_ERROR_INVALID_ARGUMENT = 8,
}
pub type int8_t = c_char;
pub type int16_t = c_short;
pub type int32_t = c_int;
pub type int64_t = c_long;
pub type uint8_t = c_uchar;
pub type uint16_t = c_ushort;
pub type uint32_t = c_uint;
pub type uint64_t = c_ulong;
pub type int_least8_t = c_char;
pub type int_least16_t = c_short;
pub type int_least32_t = c_int;
pub type int_least64_t = c_long;
pub type uint_least8_t = c_uchar;
pub type uint_least16_t = c_ushort;
pub type uint_least32_t = c_uint;
pub type uint_least64_t = c_ulong;
pub type int_fast8_t = c_char;
pub type int_fast16_t = c_long;
pub type int_fast32_t = c_long;
pub type int_fast64_t = c_long;
pub type uint_fast8_t = c_uchar;
pub type uint_fast16_t = c_ulong;
pub type uint_fast32_t = c_ulong;
pub type uint_fast64_t = c_ulong;
pub type intptr_t = c_long;
pub type uintptr_t = c_ulong;
pub type intmax_t = c_long;
pub type uintmax_t = c_ulong;
pub type __u_char = c_uchar;
pub type __u_short = c_ushort;
pub type __u_int = c_uint;
pub type __u_long = c_ulong;
pub type __int8_t = c_char;
pub type __uint8_t = c_uchar;
pub type __int16_t = c_short;
pub type __uint16_t = c_ushort;
pub type __int32_t = c_int;
pub type __uint32_t = c_uint;
pub type __int64_t = c_long;
pub type __uint64_t = c_ulong;
pub type __quad_t = c_long;
pub type __u_quad_t = c_ulong;
pub type __dev_t = c_ulong;
pub type __uid_t = c_uint;
pub type __gid_t = c_uint;
pub type __ino_t = c_ulong;
pub type __ino64_t = c_ulong;
pub type __mode_t = c_uint;
pub type __nlink_t = c_ulong;
pub type __off_t = c_long;
pub type __off64_t = c_long;
pub type __pid_t = c_int;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed9 {
    pub __val: [c_int; 2usize],
}
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() } }
}
pub type __fsid_t = Struct_Unnamed9;
pub type __clock_t = c_long;
pub type __rlim_t = c_ulong;
pub type __rlim64_t = c_ulong;
pub type __id_t = c_uint;
pub type __time_t = c_long;
pub type __useconds_t = c_uint;
pub type __suseconds_t = c_long;
pub type __daddr_t = c_int;
pub type __key_t = c_int;
pub type __clockid_t = c_int;
pub type __timer_t = *mut c_void;
pub type __blksize_t = c_long;
pub type __blkcnt_t = c_long;
pub type __blkcnt64_t = c_long;
pub type __fsblkcnt_t = c_ulong;
pub type __fsblkcnt64_t = c_ulong;
pub type __fsfilcnt_t = c_ulong;
pub type __fsfilcnt64_t = c_ulong;
pub type __fsword_t = c_long;
pub type __ssize_t = c_long;
pub type __syscall_slong_t = c_long;
pub type __syscall_ulong_t = c_ulong;
pub type __loff_t = __off64_t;
pub type __qaddr_t = *mut __quad_t;
pub type __caddr_t = *mut c_char;
pub type __intptr_t = c_long;
pub type __socklen_t = c_uint;
pub type time_t = __time_t;
#[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 __sig_atomic_t = c_int;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed10 {
    pub __val: [c_ulong; 16usize],
}
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() } }
}
pub type __sigset_t = Struct_Unnamed10;
pub type sigset_t = __sigset_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() } }
}
pub type suseconds_t = __suseconds_t;
pub type __fd_mask = c_long;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed11 {
    pub __fds_bits: [__fd_mask; 16usize],
}
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() } }
}
pub type fd_set = Struct_Unnamed11;
pub type fd_mask = __fd_mask;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_timezone {
    pub tz_minuteswest: c_int,
    pub tz_dsttime: c_int,
}
impl ::std::clone::Clone for Struct_timezone {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_timezone {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type __timezone_ptr_t = *mut Struct_timezone;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum___itimer_which {
    ITIMER_REAL = 0,
    ITIMER_VIRTUAL = 1,
    ITIMER_PROF = 2,
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_itimerval {
    pub it_interval: Struct_timeval,
    pub it_value: Struct_timeval,
}
impl ::std::clone::Clone for Struct_itimerval {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_itimerval {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type __itimer_which_t = c_int;
pub type clock_t = __clock_t;
pub type clockid_t = __clockid_t;
pub type timer_t = __timer_t;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_tm {
    pub tm_sec: c_int,
    pub tm_min: c_int,
    pub tm_hour: c_int,
    pub tm_mday: c_int,
    pub tm_mon: c_int,
    pub tm_year: c_int,
    pub tm_wday: c_int,
    pub tm_yday: c_int,
    pub tm_isdst: c_int,
    pub tm_gmtoff: c_long,
    pub tm_zone: *const 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 c_ushort,
    pub __ctype_tolower: *const c_int,
    pub __ctype_toupper: *const c_int,
    pub __names: [*const 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;
#[repr(C)]
#[derive(Copy)]
pub struct Union_wait {
    pub _bindgen_data_: [u32; 1usize],
}
impl Union_wait {
    pub unsafe fn w_status(&mut self) -> *mut c_int {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __wait_terminated(&mut self) -> *mut Struct_Unnamed12 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __wait_stopped(&mut self) -> *mut Struct_Unnamed13 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_wait {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_wait {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed12 {
    pub _bindgen_bitfield_1_: c_uint,
}
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 _bindgen_bitfield_1_: c_uint,
}
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 Union_Unnamed14 {
    pub _bindgen_data_: [u64; 1usize],
}
impl Union_Unnamed14 {
    pub unsafe fn __uptr(&mut self) -> *mut *mut Union_wait {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __iptr(&mut self) -> *mut *mut c_int {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed14 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed14 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type __WAIT_STATUS = Union_Unnamed14;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed15 {
    pub quot: c_int,
    pub rem: c_int,
}
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 div_t = Struct_Unnamed15;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed16 {
    pub quot: c_long,
    pub rem: c_long,
}
impl ::std::clone::Clone for Struct_Unnamed16 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed16 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type ldiv_t = Struct_Unnamed16;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed17 {
    pub quot: c_longlong,
    pub rem: c_longlong,
}
impl ::std::clone::Clone for Struct_Unnamed17 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed17 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type lldiv_t = Struct_Unnamed17;
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 uid_t = __uid_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 = c_ulong;
pub type ushort = c_ushort;
pub type _uint = c_uint;
pub type u_int8_t = c_uchar;
pub type u_int16_t = c_ushort;
pub type u_int32_t = c_uint;
pub type u_int64_t = c_ulong;
pub type register_t = c_long;
pub type blksize_t = __blksize_t;
pub type blkcnt_t = __blkcnt_t;
pub type fsblkcnt_t = __fsblkcnt_t;
pub type fsfilcnt_t = __fsfilcnt_t;
pub type pthread_t = 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 [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 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() } }
}
pub type pthread_attr_t = Union_pthread_attr_t;
#[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_Unnamed18 {
    pub _bindgen_data_: [u64; 5usize],
}
impl Union_Unnamed18 {
    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 [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 c_long {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed18 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed18 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct___pthread_mutex_s {
    pub __lock: c_int,
    pub __count: c_uint,
    pub __owner: c_int,
    pub __nusers: c_uint,
    pub __kind: c_int,
    pub __spins: c_short,
    pub __elision: 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_Unnamed18;
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed19 {
    pub _bindgen_data_: [u32; 1usize],
}
impl Union_Unnamed19 {
    pub unsafe fn __size(&mut self) -> *mut [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 c_int {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed19 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed19 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type pthread_mutexattr_t = Union_Unnamed19;
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed20 {
    pub _bindgen_data_: [u64; 6usize],
}
impl Union_Unnamed20 {
    pub unsafe fn __data(&mut self) -> *mut Struct_Unnamed21 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __size(&mut self)
     -> *mut [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 c_longlong {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed20 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed20 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed21 {
    pub __lock: c_int,
    pub __futex: c_uint,
    pub __total_seq: c_ulonglong,
    pub __wakeup_seq: c_ulonglong,
    pub __woken_seq: c_ulonglong,
    pub __mutex: *mut c_void,
    pub __nwaiters: c_uint,
    pub __broadcast_seq: c_uint,
}
impl ::std::clone::Clone for Struct_Unnamed21 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed21 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type pthread_cond_t = Union_Unnamed20;
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed22 {
    pub _bindgen_data_: [u32; 1usize],
}
impl Union_Unnamed22 {
    pub unsafe fn __size(&mut self) -> *mut [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 c_int {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed22 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed22 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type pthread_condattr_t = Union_Unnamed22;
pub type pthread_key_t = c_uint;
pub type pthread_once_t = c_int;
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed23 {
    pub _bindgen_data_: [u64; 7usize],
}
impl Union_Unnamed23 {
    pub unsafe fn __data(&mut self) -> *mut Struct_Unnamed24 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn __size(&mut self)
     -> *mut [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 c_long {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed23 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed23 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed24 {
    pub __lock: c_int,
    pub __nr_readers: c_uint,
    pub __readers_wakeup: c_uint,
    pub __writer_wakeup: c_uint,
    pub __nr_readers_queued: c_uint,
    pub __nr_writers_queued: c_uint,
    pub __writer: c_int,
    pub __shared: c_int,
    pub __rwelision: c_char,
    pub __pad1: [c_uchar; 7usize],
    pub __pad2: c_ulong,
    pub __flags: c_uint,
}
impl ::std::clone::Clone for Struct_Unnamed24 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed24 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type pthread_rwlock_t = Union_Unnamed23;
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed25 {
    pub _bindgen_data_: [u64; 1usize],
}
impl Union_Unnamed25 {
    pub unsafe fn __size(&mut self) -> *mut [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 c_long {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed25 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed25 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type pthread_rwlockattr_t = Union_Unnamed25;
pub type pthread_spinlock_t = c_int;
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed26 {
    pub _bindgen_data_: [u64; 4usize],
}
impl Union_Unnamed26 {
    pub unsafe fn __size(&mut self)
     -> *mut [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 c_long {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed26 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed26 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type pthread_barrier_t = Union_Unnamed26;
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed27 {
    pub _bindgen_data_: [u32; 1usize],
}
impl Union_Unnamed27 {
    pub unsafe fn __size(&mut self) -> *mut [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 c_int {
        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() } }
}
pub type pthread_barrierattr_t = Union_Unnamed27;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_random_data {
    pub fptr: *mut int32_t,
    pub rptr: *mut int32_t,
    pub state: *mut int32_t,
    pub rand_type: c_int,
    pub rand_deg: c_int,
    pub rand_sep: c_int,
    pub end_ptr: *mut int32_t,
}
impl ::std::clone::Clone for Struct_random_data {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_random_data {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_drand48_data {
    pub __x: [c_ushort; 3usize],
    pub __old_x: [c_ushort; 3usize],
    pub __c: c_ushort,
    pub __init: c_ushort,
    pub __a: c_ulonglong,
}
impl ::std::clone::Clone for Struct_drand48_data {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_drand48_data {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type __compar_fn_t =
    ::std::option::Option<unsafe extern "C" fn(arg1:
                                                   *const c_void,
                                               arg2:
                                                   *const c_void)
                              -> c_int>;
pub type scm_t_int8 = int8_t;
pub type scm_t_uint8 = uint8_t;
pub type scm_t_int16 = int16_t;
pub type scm_t_uint16 = uint16_t;
pub type scm_t_int32 = int32_t;
pub type scm_t_uint32 = uint32_t;
pub type scm_t_intmax = intmax_t;
pub type scm_t_uintmax = uintmax_t;
pub type scm_t_intptr = intptr_t;
pub type scm_t_uintptr = uintptr_t;
pub type scm_t_int64 = int64_t;
pub type scm_t_uint64 = uint64_t;
pub type scm_t_ptrdiff = ptrdiff_t;
pub type scm_t_timespec = Struct_timespec;
pub type scm_t_off = scm_t_int64;
pub type scm_t_signed_bits = scm_t_intptr;
pub type scm_t_bits = scm_t_uintptr;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_unused_struct {
    pub scm_unused_field: c_char,
}
impl ::std::clone::Clone for Struct_scm_unused_struct {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_unused_struct {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type SCM = *mut Struct_scm_unused_struct;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_scm_tc8_tags {
    scm_tc8_flag = 4,
    scm_tc8_char = 12,
    scm_tc8_unused_0 = 20,
    scm_tc8_unused_1 = 28,
}
pub type scm_t_subr = *mut c_void;
pub type __jmp_buf = [c_long; 8usize];
#[repr(C)]
#[derive(Copy)]
pub struct Struct___jmp_buf_tag {
    pub __jmpbuf: __jmp_buf,
    pub __mask_was_saved: 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 SCM_STACKITEM = c_long;
pub type scm_t_wchar = scm_t_int32;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_t_option {
    pub _type: c_uint,
    pub name: *const c_char,
    pub val: scm_t_bits,
    pub doc: *mut c_char,
}
impl ::std::clone::Clone for Struct_scm_t_option {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_t_option {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_option = Struct_scm_t_option;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_print_state {
    pub handle: SCM,
    pub revealed: c_int,
    pub writingp: c_ulong,
    pub fancyp: c_ulong,
    pub level: c_ulong,
    pub length: c_ulong,
    pub hot_ref: SCM,
    pub list_offset: c_ulong,
    pub top: c_ulong,
    pub ceiling: c_ulong,
    pub ref_vect: SCM,
    pub highlight_objects: SCM,
}
impl ::std::clone::Clone for Struct_scm_print_state {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_print_state {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_print_state = Struct_scm_print_state;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_t_double {
    pub _type: SCM,
    pub pad: SCM,
    pub real: c_double,
}
impl ::std::clone::Clone for Struct_scm_t_double {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_t_double {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_double = Struct_scm_t_double;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_t_complex {
    pub _type: SCM,
    pub pad: SCM,
    pub real: c_double,
    pub imag: c_double,
}
impl ::std::clone::Clone for Struct_scm_t_complex {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_t_complex {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_complex = Struct_scm_t_complex;
pub type scm_i_t_array_ref =
    ::std::option::Option<unsafe extern "C" fn(arg1:
                                                   *mut Struct_scm_t_array_handle,
                                               arg2: size_t) -> SCM>;
pub type scm_i_t_array_set =
    ::std::option::Option<unsafe extern "C" fn(arg1:
                                                   *mut Struct_scm_t_array_handle,
                                               arg2: size_t, arg3: SCM)>;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed28 {
    pub tag: scm_t_bits,
    pub mask: scm_t_bits,
    pub vref: scm_i_t_array_ref,
    pub vset: scm_i_t_array_set,
    pub get_handle: ::std::option::Option<unsafe extern "C" fn(arg1: SCM,
                                                               arg2:
                                                                   *mut Struct_scm_t_array_handle)>,
}
impl ::std::clone::Clone for Struct_Unnamed28 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed28 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_array_implementation = Struct_Unnamed28;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_t_array_dim {
    pub lbnd: ssize_t,
    pub ubnd: ssize_t,
    pub inc: ssize_t,
}
impl ::std::clone::Clone for Struct_scm_t_array_dim {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_t_array_dim {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_array_dim = Struct_scm_t_array_dim;
pub const SCM_ARRAY_ELEMENT_TYPE_LAST: Enum_Unnamed29 =
    Enum_Unnamed29::SCM_ARRAY_ELEMENT_TYPE_C64;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed29 {
    SCM_ARRAY_ELEMENT_TYPE_SCM = 0,
    SCM_ARRAY_ELEMENT_TYPE_CHAR = 1,
    SCM_ARRAY_ELEMENT_TYPE_BIT = 2,
    SCM_ARRAY_ELEMENT_TYPE_VU8 = 3,
    SCM_ARRAY_ELEMENT_TYPE_U8 = 4,
    SCM_ARRAY_ELEMENT_TYPE_S8 = 5,
    SCM_ARRAY_ELEMENT_TYPE_U16 = 6,
    SCM_ARRAY_ELEMENT_TYPE_S16 = 7,
    SCM_ARRAY_ELEMENT_TYPE_U32 = 8,
    SCM_ARRAY_ELEMENT_TYPE_S32 = 9,
    SCM_ARRAY_ELEMENT_TYPE_U64 = 10,
    SCM_ARRAY_ELEMENT_TYPE_S64 = 11,
    SCM_ARRAY_ELEMENT_TYPE_F32 = 12,
    SCM_ARRAY_ELEMENT_TYPE_F64 = 13,
    SCM_ARRAY_ELEMENT_TYPE_C32 = 14,
    SCM_ARRAY_ELEMENT_TYPE_C64 = 15,
}
pub type scm_t_array_element_type = Enum_Unnamed29;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_t_array_handle {
    pub array: SCM,
    pub _impl: *mut scm_t_array_implementation,
    pub base: size_t,
    pub ndims: size_t,
    pub dims: *mut scm_t_array_dim,
    pub dim0: scm_t_array_dim,
    pub element_type: scm_t_array_element_type,
    pub elements: *const c_void,
    pub writable_elements: *mut c_void,
}
impl ::std::clone::Clone for Struct_scm_t_array_handle {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_t_array_handle {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_array_handle = Struct_scm_t_array_handle;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_i_t_array {
    pub v: SCM,
    pub base: c_ulong,
}
impl ::std::clone::Clone for Struct_scm_i_t_array {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_i_t_array {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_i_t_array = Struct_scm_i_t_array;
#[repr(C)]
#[derive(Copy)]
pub struct Union_scm_t_debug_info {
    pub _bindgen_data_: [u64; 2usize],
}
impl Union_scm_t_debug_info {
    pub unsafe fn e(&mut self) -> *mut Struct_Unnamed30 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn a(&mut self) -> *mut Struct_Unnamed31 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn id(&mut self) -> *mut SCM {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_scm_t_debug_info {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_scm_t_debug_info {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed30 {
    pub exp: SCM,
    pub env: SCM,
}
impl ::std::clone::Clone for Struct_Unnamed30 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed30 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed31 {
    pub _proc: SCM,
    pub args: SCM,
}
impl ::std::clone::Clone for Struct_Unnamed31 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed31 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_debug_info = Union_scm_t_debug_info;
pub type scm_t_catch_body =
    ::std::option::Option<unsafe extern "C" fn(data:
                                                   *mut c_void)
                              -> SCM>;
pub type scm_t_catch_handler =
    ::std::option::Option<unsafe extern "C" fn(data:
                                                   *mut c_void,
                                               tag: SCM, throw_args: SCM)
                              -> SCM>;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_body_thunk_data {
    pub tag: SCM,
    pub body_proc: SCM,
}
impl ::std::clone::Clone for Struct_scm_body_thunk_data {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_body_thunk_data {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_guard =
    ::std::option::Option<unsafe extern "C" fn(arg1:
                                                   *mut c_void)>;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed32 { SCM_F_DYNWIND_REWINDABLE = 1, }
pub type scm_t_dynwind_flags = Enum_Unnamed32;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed33 { SCM_F_WIND_EXPLICITLY = 1, }
pub type scm_t_wind_flags = Enum_Unnamed33;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed34 {
    pub jmpbuf: jmp_buf,
    pub dynenv: SCM,
    pub num_stack_items: size_t,
    pub root: SCM,
    pub vm: SCM,
    pub vm_cont: SCM,
    pub offset: scm_t_ptrdiff,
    pub stack: [SCM_STACKITEM; 1usize],
}
impl ::std::clone::Clone for Struct_Unnamed34 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed34 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_contregs = Struct_Unnamed34;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_sched_param {
    pub __sched_priority: 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: 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 = c_ulong;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed35 {
    pub __bits: [__cpu_mask; 16usize],
}
impl ::std::clone::Clone for Struct_Unnamed35 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed35 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type cpu_set_t = Struct_Unnamed35;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed36 {
    PTHREAD_CREATE_JOINABLE = 0,
    PTHREAD_CREATE_DETACHED = 1,
}
pub const PTHREAD_MUTEX_NORMAL: Enum_Unnamed37 =
    Enum_Unnamed37::PTHREAD_MUTEX_TIMED_NP;
pub const PTHREAD_MUTEX_RECURSIVE: Enum_Unnamed37 =
    Enum_Unnamed37::PTHREAD_MUTEX_RECURSIVE_NP;
pub const PTHREAD_MUTEX_ERRORCHECK: Enum_Unnamed37 =
    Enum_Unnamed37::PTHREAD_MUTEX_ERRORCHECK_NP;
pub const PTHREAD_MUTEX_DEFAULT: Enum_Unnamed37 =
    Enum_Unnamed37::PTHREAD_MUTEX_TIMED_NP;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed37 {
    PTHREAD_MUTEX_TIMED_NP = 0,
    PTHREAD_MUTEX_RECURSIVE_NP = 1,
    PTHREAD_MUTEX_ERRORCHECK_NP = 2,
    PTHREAD_MUTEX_ADAPTIVE_NP = 3,
}
pub const PTHREAD_MUTEX_STALLED_NP: Enum_Unnamed38 =
    Enum_Unnamed38::PTHREAD_MUTEX_STALLED;
pub const PTHREAD_MUTEX_ROBUST_NP: Enum_Unnamed38 =
    Enum_Unnamed38::PTHREAD_MUTEX_ROBUST;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed38 {
    PTHREAD_MUTEX_STALLED = 0,
    PTHREAD_MUTEX_ROBUST = 1,
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed39 {
    PTHREAD_PRIO_NONE = 0,
    PTHREAD_PRIO_INHERIT = 1,
    PTHREAD_PRIO_PROTECT = 2,
}
pub const PTHREAD_RWLOCK_DEFAULT_NP: Enum_Unnamed40 =
    Enum_Unnamed40::PTHREAD_RWLOCK_PREFER_READER_NP;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed40 {
    PTHREAD_RWLOCK_PREFER_READER_NP = 0,
    PTHREAD_RWLOCK_PREFER_WRITER_NP = 1,
    PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP = 2,
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed41 {
    PTHREAD_INHERIT_SCHED = 0,
    PTHREAD_EXPLICIT_SCHED = 1,
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed42 {
    PTHREAD_SCOPE_SYSTEM = 0,
    PTHREAD_SCOPE_PROCESS = 1,
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed43 {
    PTHREAD_PROCESS_PRIVATE = 0,
    PTHREAD_PROCESS_SHARED = 1,
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__pthread_cleanup_buffer {
    pub __routine: ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                  *mut c_void)>,
    pub __arg: *mut c_void,
    pub __canceltype: 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() } }
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed44 {
    PTHREAD_CANCEL_ENABLE = 0,
    PTHREAD_CANCEL_DISABLE = 1,
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed45 {
    PTHREAD_CANCEL_DEFERRED = 0,
    PTHREAD_CANCEL_ASYNCHRONOUS = 1,
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed46 {
    pub __cancel_jmp_buf: [Struct_Unnamed47; 1usize],
    pub __pad: [*mut c_void; 4usize],
}
impl ::std::clone::Clone for Struct_Unnamed46 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed46 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed47 {
    pub __cancel_jmp_buf: __jmp_buf,
    pub __mask_was_saved: c_int,
}
impl ::std::clone::Clone for Struct_Unnamed47 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed47 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type __pthread_unwind_buf_t = Struct_Unnamed46;
#[repr(C)]
#[derive(Copy)]
pub struct Struct___pthread_cleanup_frame {
    pub __cancel_routine: ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                         *mut c_void)>,
    pub __cancel_arg: *mut c_void,
    pub __do_it: c_int,
    pub __cancel_type: 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() } }
}
pub type GC_PTR = *mut c_void;
pub type GC_word = c_ulong;
pub type GC_signed_word = c_long;
pub type GC_oom_func =
    ::std::option::Option<extern "C" fn(arg1: size_t)
                              -> *mut c_void>;
pub type GC_on_heap_resize_proc =
    ::std::option::Option<extern "C" fn(arg1: GC_word)>;
pub type GC_finalizer_notifier_proc = ::std::option::Option<extern "C" fn()>;
pub type GC_stop_func =
    ::std::option::Option<extern "C" fn() -> c_int>;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_GC_prof_stats_s {
    pub heapsize_full: GC_word,
    pub free_bytes_full: GC_word,
    pub unmapped_bytes: GC_word,
    pub bytes_allocd_since_gc: GC_word,
    pub allocd_bytes_before_gc: GC_word,
    pub non_gc_bytes: GC_word,
    pub gc_no: GC_word,
    pub markers_m1: GC_word,
    pub bytes_reclaimed_since_gc: GC_word,
    pub reclaimed_bytes_before_gc: GC_word,
}
impl ::std::clone::Clone for Struct_GC_prof_stats_s {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_GC_prof_stats_s {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type GC_finalization_proc =
    ::std::option::Option<unsafe extern "C" fn(arg1:
                                                   *mut c_void,
                                               arg2:
                                                   *mut c_void)>;
pub type GC_warn_proc =
    ::std::option::Option<unsafe extern "C" fn(arg1:
                                                   *mut c_char,
                                               arg2: GC_word)>;
pub type GC_abort_func =
    ::std::option::Option<unsafe extern "C" fn(arg1:
                                                   *const c_char)>;
pub type GC_hidden_pointer = GC_word;
pub type GC_fn_type =
    ::std::option::Option<unsafe extern "C" fn(arg1:
                                                   *mut c_void)
                              -> *mut c_void>;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_GC_stack_base {
    pub mem_base: *mut c_void,
}
impl ::std::clone::Clone for Struct_GC_stack_base {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_GC_stack_base {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type GC_stack_base_func =
    ::std::option::Option<unsafe extern "C" fn(arg1:
                                                   *mut Struct_GC_stack_base,
                                               arg2:
                                                   *mut c_void)
                              -> *mut c_void>;
pub type sig_atomic_t = __sig_atomic_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 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 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_Unnamed48 {
    pub si_signo: c_int,
    pub si_errno: c_int,
    pub si_code: c_int,
    pub _sifields: Union_Unnamed49,
}
impl ::std::clone::Clone for Struct_Unnamed48 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed48 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed49 {
    pub _bindgen_data_: [u64; 14usize],
}
impl Union_Unnamed49 {
    pub unsafe fn _pad(&mut self) -> *mut [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_Unnamed50 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn _timer(&mut self) -> *mut Struct_Unnamed51 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn _rt(&mut self) -> *mut Struct_Unnamed52 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn _sigchld(&mut self) -> *mut Struct_Unnamed53 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn _sigfault(&mut self) -> *mut Struct_Unnamed54 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn _sigpoll(&mut self) -> *mut Struct_Unnamed56 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
    pub unsafe fn _sigsys(&mut self) -> *mut Struct_Unnamed57 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed49 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed49 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed50 {
    pub si_pid: __pid_t,
    pub si_uid: __uid_t,
}
impl ::std::clone::Clone for Struct_Unnamed50 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed50 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed51 {
    pub si_tid: c_int,
    pub si_overrun: c_int,
    pub si_sigval: sigval_t,
}
impl ::std::clone::Clone for Struct_Unnamed51 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed51 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed52 {
    pub si_pid: __pid_t,
    pub si_uid: __uid_t,
    pub si_sigval: sigval_t,
}
impl ::std::clone::Clone for Struct_Unnamed52 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed52 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed53 {
    pub si_pid: __pid_t,
    pub si_uid: __uid_t,
    pub si_status: c_int,
    pub si_utime: __sigchld_clock_t,
    pub si_stime: __sigchld_clock_t,
}
impl ::std::clone::Clone for Struct_Unnamed53 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed53 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed54 {
    pub si_addr: *mut c_void,
    pub si_addr_lsb: c_short,
    pub si_addr_bnd: Struct_Unnamed55,
}
impl ::std::clone::Clone for Struct_Unnamed54 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed54 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed55 {
    pub _lower: *mut c_void,
    pub _upper: *mut c_void,
}
impl ::std::clone::Clone for Struct_Unnamed55 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed55 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed56 {
    pub si_band: c_long,
    pub si_fd: c_int,
}
impl ::std::clone::Clone for Struct_Unnamed56 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed56 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed57 {
    pub _call_addr: *mut c_void,
    pub _syscall: c_int,
    pub _arch: c_uint,
}
impl ::std::clone::Clone for Struct_Unnamed57 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed57 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type siginfo_t = Struct_Unnamed48;
#[derive(Clone, Copy)]
#[repr(i32)]
pub enum Enum_Unnamed58 {
    SI_ASYNCNL = -60,
    SI_TKILL = -6,
    SI_SIGIO = -5,
    SI_ASYNCIO = -4,
    SI_MESGQ = -3,
    SI_TIMER = -2,
    SI_QUEUE = -1,
    SI_USER = 0,
    SI_KERNEL = 128,
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed59 {
    ILL_ILLOPC = 1,
    ILL_ILLOPN = 2,
    ILL_ILLADR = 3,
    ILL_ILLTRP = 4,
    ILL_PRVOPC = 5,
    ILL_PRVREG = 6,
    ILL_COPROC = 7,
    ILL_BADSTK = 8,
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed60 {
    FPE_INTDIV = 1,
    FPE_INTOVF = 2,
    FPE_FLTDIV = 3,
    FPE_FLTOVF = 4,
    FPE_FLTUND = 5,
    FPE_FLTRES = 6,
    FPE_FLTINV = 7,
    FPE_FLTSUB = 8,
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed61 { SEGV_MAPERR = 1, SEGV_ACCERR = 2, }
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed62 {
    BUS_ADRALN = 1,
    BUS_ADRERR = 2,
    BUS_OBJERR = 3,
    BUS_MCEERR_AR = 4,
    BUS_MCEERR_AO = 5,
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed63 {
    CLD_EXITED = 1,
    CLD_KILLED = 2,
    CLD_DUMPED = 3,
    CLD_TRAPPED = 4,
    CLD_STOPPED = 5,
    CLD_CONTINUED = 6,
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed64 {
    POLL_IN = 1,
    POLL_OUT = 2,
    POLL_MSG = 3,
    POLL_ERR = 4,
    POLL_PRI = 5,
    POLL_HUP = 6,
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_sigevent {
    pub sigev_value: sigval_t,
    pub sigev_signo: c_int,
    pub sigev_notify: c_int,
    pub _sigev_un: Union_Unnamed65,
}
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_Unnamed65 {
    pub _bindgen_data_: [u64; 6usize],
}
impl Union_Unnamed65 {
    pub unsafe fn _pad(&mut self) -> *mut [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_Unnamed66 {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed65 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed65 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed66 {
    pub _function: ::std::option::Option<extern "C" fn(arg1: sigval_t)>,
    pub _attribute: *mut pthread_attr_t,
}
impl ::std::clone::Clone for Struct_Unnamed66 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed66 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type sigevent_t = Struct_sigevent;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed67 {
    SIGEV_SIGNAL = 0,
    SIGEV_NONE = 1,
    SIGEV_THREAD = 2,
    SIGEV_THREAD_ID = 4,
}
pub type __sighandler_t =
    ::std::option::Option<extern "C" fn(arg1: c_int)>;
pub type sig_t = __sighandler_t;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_sigaction {
    pub __sigaction_handler: Union_Unnamed68,
    pub sa_mask: __sigset_t,
    pub sa_flags: 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_Unnamed68 {
    pub _bindgen_data_: [u64; 1usize],
}
impl Union_Unnamed68 {
    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<unsafe extern "C" fn(arg1:
                                                             c_int,
                                                         arg2: *mut siginfo_t,
                                                         arg3:
                                                             *mut c_void)> {
        let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
        ::std::mem::transmute(raw.offset(0))
    }
}
impl ::std::clone::Clone for Union_Unnamed68 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed68 {
    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: [c_ushort; 4usize],
    pub exponent: 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: [c_ushort; 4usize],
    pub exponent: c_ushort,
    pub padding: [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: c_ushort,
    pub gs: c_ushort,
    pub fs: c_ushort,
    pub __pad0: 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 c_void,
    pub ss_onstack: 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() } }
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed69 { SS_ONSTACK = 1, SS_DISABLE = 2, }
#[repr(C)]
#[derive(Copy)]
pub struct Struct_sigaltstack {
    pub ss_sp: *mut c_void,
    pub ss_flags: 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 = c_longlong;
pub type gregset_t = [greg_t; 23usize];
#[repr(C)]
#[derive(Copy)]
pub struct Struct__libc_fpxreg {
    pub significand: [c_ushort; 4usize],
    pub exponent: c_ushort,
    pub padding: [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_Unnamed70 {
    pub gregs: gregset_t,
    pub fpregs: fpregset_t,
    pub __reserved1: [c_ulonglong; 8usize],
}
impl ::std::clone::Clone for Struct_Unnamed70 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed70 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type mcontext_t = Struct_Unnamed70;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_ucontext {
    pub uc_flags: 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 GC_has_static_roots_func =
    ::std::option::Option<unsafe extern "C" fn(arg1:
                                                   *const c_char,
                                               arg2:
                                                   *mut c_void,
                                               arg3: size_t)
                              -> c_int>;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_i_thread {
    pub next_thread: *mut Struct_scm_i_thread,
    pub handle: SCM,
    pub pthread: pthread_t,
    pub cleanup_handler: SCM,
    pub join_queue: SCM,
    pub admin_mutex: pthread_mutex_t,
    pub mutexes: SCM,
    pub held_mutex: *mut pthread_mutex_t,
    pub result: SCM,
    pub canceled: c_int,
    pub exited: c_int,
    pub guile_mode: c_int,
    pub sleep_object: SCM,
    pub sleep_mutex: *mut pthread_mutex_t,
    pub sleep_cond: pthread_cond_t,
    pub sleep_fd: c_int,
    pub sleep_pipe: [c_int; 2usize],
    pub current_mark_stack_ptr: *mut c_void,
    pub current_mark_stack_limit: *mut c_void,
    pub dynamic_state: SCM,
    pub dynwinds: SCM,
    pub active_asyncs: SCM,
    pub block_asyncs: c_uint,
    pub pending_asyncs: c_uint,
    pub continuation_root: SCM,
    pub continuation_base: *mut SCM_STACKITEM,
    pub vm: SCM,
    pub base: *mut SCM_STACKITEM,
    pub regs: jmp_buf,
    pub critical_section_level: c_int,
}
impl ::std::clone::Clone for Struct_scm_i_thread {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_i_thread {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_i_thread = Struct_scm_i_thread;
pub type scm_t_struct_finalize =
    ::std::option::Option<extern "C" fn(obj: SCM)>;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed71 {
    SCM_M_BEGIN = 0,
    SCM_M_IF = 1,
    SCM_M_LAMBDA = 2,
    SCM_M_LET = 3,
    SCM_M_QUOTE = 4,
    SCM_M_DEFINE = 5,
    SCM_M_DYNWIND = 6,
    SCM_M_WITH_FLUIDS = 7,
    SCM_M_APPLY = 8,
    SCM_M_CONT = 9,
    SCM_M_CALL_WITH_VALUES = 10,
    SCM_M_CALL = 11,
    SCM_M_LEXICAL_REF = 12,
    SCM_M_LEXICAL_SET = 13,
    SCM_M_TOPLEVEL_REF = 14,
    SCM_M_TOPLEVEL_SET = 15,
    SCM_M_MODULE_REF = 16,
    SCM_M_MODULE_SET = 17,
    SCM_M_PROMPT = 18,
}
pub type scm_t_trampoline_0 =
    ::std::option::Option<extern "C" fn(_proc: SCM) -> SCM>;
pub type scm_t_trampoline_1 =
    ::std::option::Option<extern "C" fn(_proc: SCM, arg1: SCM) -> SCM>;
pub type scm_t_trampoline_2 =
    ::std::option::Option<extern "C" fn(_proc: SCM, arg1: SCM, arg2: SCM)
                              -> SCM>;
pub type scm_t_extension_init_func =
    ::std::option::Option<unsafe extern "C" fn(arg1:
                                                   *mut c_void)>;
pub type scm_t_finalizer_proc =
    ::std::option::Option<unsafe extern "C" fn(obj:
                                                   *mut c_void,
                                               data:
                                                   *mut c_void)>;
pub const SCM_FOREIGN_TYPE_LAST: Enum_scm_t_foreign_type =
    Enum_scm_t_foreign_type::SCM_FOREIGN_TYPE_INT64;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_scm_t_foreign_type {
    SCM_FOREIGN_TYPE_VOID = 0,
    SCM_FOREIGN_TYPE_FLOAT = 1,
    SCM_FOREIGN_TYPE_DOUBLE = 2,
    SCM_FOREIGN_TYPE_UINT8 = 3,
    SCM_FOREIGN_TYPE_INT8 = 4,
    SCM_FOREIGN_TYPE_UINT16 = 5,
    SCM_FOREIGN_TYPE_INT16 = 6,
    SCM_FOREIGN_TYPE_UINT32 = 7,
    SCM_FOREIGN_TYPE_INT32 = 8,
    SCM_FOREIGN_TYPE_UINT64 = 9,
    SCM_FOREIGN_TYPE_INT64 = 10,
}
pub type scm_t_foreign_type = Enum_scm_t_foreign_type;
pub type scm_t_pointer_finalizer =
    ::std::option::Option<unsafe extern "C" fn(arg1:
                                                   *mut c_void)>;
pub type useconds_t = __useconds_t;
pub type socklen_t = __socklen_t;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed72 {
    _PC_LINK_MAX = 0,
    _PC_MAX_CANON = 1,
    _PC_MAX_INPUT = 2,
    _PC_NAME_MAX = 3,
    _PC_PATH_MAX = 4,
    _PC_PIPE_BUF = 5,
    _PC_CHOWN_RESTRICTED = 6,
    _PC_NO_TRUNC = 7,
    _PC_VDISABLE = 8,
    _PC_SYNC_IO = 9,
    _PC_ASYNC_IO = 10,
    _PC_PRIO_IO = 11,
    _PC_SOCK_MAXBUF = 12,
    _PC_FILESIZEBITS = 13,
    _PC_REC_INCR_XFER_SIZE = 14,
    _PC_REC_MAX_XFER_SIZE = 15,
    _PC_REC_MIN_XFER_SIZE = 16,
    _PC_REC_XFER_ALIGN = 17,
    _PC_ALLOC_SIZE_MIN = 18,
    _PC_SYMLINK_MAX = 19,
    _PC_2_SYMLINKS = 20,
}
pub const _SC_IOV_MAX: Enum_Unnamed73 = Enum_Unnamed73::_SC_UIO_MAXIOV;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed73 {
    _SC_ARG_MAX = 0,
    _SC_CHILD_MAX = 1,
    _SC_CLK_TCK = 2,
    _SC_NGROUPS_MAX = 3,
    _SC_OPEN_MAX = 4,
    _SC_STREAM_MAX = 5,
    _SC_TZNAME_MAX = 6,
    _SC_JOB_CONTROL = 7,
    _SC_SAVED_IDS = 8,
    _SC_REALTIME_SIGNALS = 9,
    _SC_PRIORITY_SCHEDULING = 10,
    _SC_TIMERS = 11,
    _SC_ASYNCHRONOUS_IO = 12,
    _SC_PRIORITIZED_IO = 13,
    _SC_SYNCHRONIZED_IO = 14,
    _SC_FSYNC = 15,
    _SC_MAPPED_FILES = 16,
    _SC_MEMLOCK = 17,
    _SC_MEMLOCK_RANGE = 18,
    _SC_MEMORY_PROTECTION = 19,
    _SC_MESSAGE_PASSING = 20,
    _SC_SEMAPHORES = 21,
    _SC_SHARED_MEMORY_OBJECTS = 22,
    _SC_AIO_LISTIO_MAX = 23,
    _SC_AIO_MAX = 24,
    _SC_AIO_PRIO_DELTA_MAX = 25,
    _SC_DELAYTIMER_MAX = 26,
    _SC_MQ_OPEN_MAX = 27,
    _SC_MQ_PRIO_MAX = 28,
    _SC_VERSION = 29,
    _SC_PAGESIZE = 30,
    _SC_RTSIG_MAX = 31,
    _SC_SEM_NSEMS_MAX = 32,
    _SC_SEM_VALUE_MAX = 33,
    _SC_SIGQUEUE_MAX = 34,
    _SC_TIMER_MAX = 35,
    _SC_BC_BASE_MAX = 36,
    _SC_BC_DIM_MAX = 37,
    _SC_BC_SCALE_MAX = 38,
    _SC_BC_STRING_MAX = 39,
    _SC_COLL_WEIGHTS_MAX = 40,
    _SC_EQUIV_CLASS_MAX = 41,
    _SC_EXPR_NEST_MAX = 42,
    _SC_LINE_MAX = 43,
    _SC_RE_DUP_MAX = 44,
    _SC_CHARCLASS_NAME_MAX = 45,
    _SC_2_VERSION = 46,
    _SC_2_C_BIND = 47,
    _SC_2_C_DEV = 48,
    _SC_2_FORT_DEV = 49,
    _SC_2_FORT_RUN = 50,
    _SC_2_SW_DEV = 51,
    _SC_2_LOCALEDEF = 52,
    _SC_PII = 53,
    _SC_PII_XTI = 54,
    _SC_PII_SOCKET = 55,
    _SC_PII_INTERNET = 56,
    _SC_PII_OSI = 57,
    _SC_POLL = 58,
    _SC_SELECT = 59,
    _SC_UIO_MAXIOV = 60,
    _SC_PII_INTERNET_STREAM = 61,
    _SC_PII_INTERNET_DGRAM = 62,
    _SC_PII_OSI_COTS = 63,
    _SC_PII_OSI_CLTS = 64,
    _SC_PII_OSI_M = 65,
    _SC_T_IOV_MAX = 66,
    _SC_THREADS = 67,
    _SC_THREAD_SAFE_FUNCTIONS = 68,
    _SC_GETGR_R_SIZE_MAX = 69,
    _SC_GETPW_R_SIZE_MAX = 70,
    _SC_LOGIN_NAME_MAX = 71,
    _SC_TTY_NAME_MAX = 72,
    _SC_THREAD_DESTRUCTOR_ITERATIONS = 73,
    _SC_THREAD_KEYS_MAX = 74,
    _SC_THREAD_STACK_MIN = 75,
    _SC_THREAD_THREADS_MAX = 76,
    _SC_THREAD_ATTR_STACKADDR = 77,
    _SC_THREAD_ATTR_STACKSIZE = 78,
    _SC_THREAD_PRIORITY_SCHEDULING = 79,
    _SC_THREAD_PRIO_INHERIT = 80,
    _SC_THREAD_PRIO_PROTECT = 81,
    _SC_THREAD_PROCESS_SHARED = 82,
    _SC_NPROCESSORS_CONF = 83,
    _SC_NPROCESSORS_ONLN = 84,
    _SC_PHYS_PAGES = 85,
    _SC_AVPHYS_PAGES = 86,
    _SC_ATEXIT_MAX = 87,
    _SC_PASS_MAX = 88,
    _SC_XOPEN_VERSION = 89,
    _SC_XOPEN_XCU_VERSION = 90,
    _SC_XOPEN_UNIX = 91,
    _SC_XOPEN_CRYPT = 92,
    _SC_XOPEN_ENH_I18N = 93,
    _SC_XOPEN_SHM = 94,
    _SC_2_CHAR_TERM = 95,
    _SC_2_C_VERSION = 96,
    _SC_2_UPE = 97,
    _SC_XOPEN_XPG2 = 98,
    _SC_XOPEN_XPG3 = 99,
    _SC_XOPEN_XPG4 = 100,
    _SC_CHAR_BIT = 101,
    _SC_CHAR_MAX = 102,
    _SC_CHAR_MIN = 103,
    _SC_INT_MAX = 104,
    _SC_INT_MIN = 105,
    _SC_LONG_BIT = 106,
    _SC_WORD_BIT = 107,
    _SC_MB_LEN_MAX = 108,
    _SC_NZERO = 109,
    _SC_SSIZE_MAX = 110,
    _SC_SCHAR_MAX = 111,
    _SC_SCHAR_MIN = 112,
    _SC_SHRT_MAX = 113,
    _SC_SHRT_MIN = 114,
    _SC_UCHAR_MAX = 115,
    _SC_UINT_MAX = 116,
    _SC_ULONG_MAX = 117,
    _SC_USHRT_MAX = 118,
    _SC_NL_ARGMAX = 119,
    _SC_NL_LANGMAX = 120,
    _SC_NL_MSGMAX = 121,
    _SC_NL_NMAX = 122,
    _SC_NL_SETMAX = 123,
    _SC_NL_TEXTMAX = 124,
    _SC_XBS5_ILP32_OFF32 = 125,
    _SC_XBS5_ILP32_OFFBIG = 126,
    _SC_XBS5_LP64_OFF64 = 127,
    _SC_XBS5_LPBIG_OFFBIG = 128,
    _SC_XOPEN_LEGACY = 129,
    _SC_XOPEN_REALTIME = 130,
    _SC_XOPEN_REALTIME_THREADS = 131,
    _SC_ADVISORY_INFO = 132,
    _SC_BARRIERS = 133,
    _SC_BASE = 134,
    _SC_C_LANG_SUPPORT = 135,
    _SC_C_LANG_SUPPORT_R = 136,
    _SC_CLOCK_SELECTION = 137,
    _SC_CPUTIME = 138,
    _SC_THREAD_CPUTIME = 139,
    _SC_DEVICE_IO = 140,
    _SC_DEVICE_SPECIFIC = 141,
    _SC_DEVICE_SPECIFIC_R = 142,
    _SC_FD_MGMT = 143,
    _SC_FIFO = 144,
    _SC_PIPE = 145,
    _SC_FILE_ATTRIBUTES = 146,
    _SC_FILE_LOCKING = 147,
    _SC_FILE_SYSTEM = 148,
    _SC_MONOTONIC_CLOCK = 149,
    _SC_MULTI_PROCESS = 150,
    _SC_SINGLE_PROCESS = 151,
    _SC_NETWORKING = 152,
    _SC_READER_WRITER_LOCKS = 153,
    _SC_SPIN_LOCKS = 154,
    _SC_REGEXP = 155,
    _SC_REGEX_VERSION = 156,
    _SC_SHELL = 157,
    _SC_SIGNALS = 158,
    _SC_SPAWN = 159,
    _SC_SPORADIC_SERVER = 160,
    _SC_THREAD_SPORADIC_SERVER = 161,
    _SC_SYSTEM_DATABASE = 162,
    _SC_SYSTEM_DATABASE_R = 163,
    _SC_TIMEOUTS = 164,
    _SC_TYPED_MEMORY_OBJECTS = 165,
    _SC_USER_GROUPS = 166,
    _SC_USER_GROUPS_R = 167,
    _SC_2_PBS = 168,
    _SC_2_PBS_ACCOUNTING = 169,
    _SC_2_PBS_LOCATE = 170,
    _SC_2_PBS_MESSAGE = 171,
    _SC_2_PBS_TRACK = 172,
    _SC_SYMLOOP_MAX = 173,
    _SC_STREAMS = 174,
    _SC_2_PBS_CHECKPOINT = 175,
    _SC_V6_ILP32_OFF32 = 176,
    _SC_V6_ILP32_OFFBIG = 177,
    _SC_V6_LP64_OFF64 = 178,
    _SC_V6_LPBIG_OFFBIG = 179,
    _SC_HOST_NAME_MAX = 180,
    _SC_TRACE = 181,
    _SC_TRACE_EVENT_FILTER = 182,
    _SC_TRACE_INHERIT = 183,
    _SC_TRACE_LOG = 184,
    _SC_LEVEL1_ICACHE_SIZE = 185,
    _SC_LEVEL1_ICACHE_ASSOC = 186,
    _SC_LEVEL1_ICACHE_LINESIZE = 187,
    _SC_LEVEL1_DCACHE_SIZE = 188,
    _SC_LEVEL1_DCACHE_ASSOC = 189,
    _SC_LEVEL1_DCACHE_LINESIZE = 190,
    _SC_LEVEL2_CACHE_SIZE = 191,
    _SC_LEVEL2_CACHE_ASSOC = 192,
    _SC_LEVEL2_CACHE_LINESIZE = 193,
    _SC_LEVEL3_CACHE_SIZE = 194,
    _SC_LEVEL3_CACHE_ASSOC = 195,
    _SC_LEVEL3_CACHE_LINESIZE = 196,
    _SC_LEVEL4_CACHE_SIZE = 197,
    _SC_LEVEL4_CACHE_ASSOC = 198,
    _SC_LEVEL4_CACHE_LINESIZE = 199,
    _SC_IPV6 = 235,
    _SC_RAW_SOCKETS = 236,
    _SC_V7_ILP32_OFF32 = 237,
    _SC_V7_ILP32_OFFBIG = 238,
    _SC_V7_LP64_OFF64 = 239,
    _SC_V7_LPBIG_OFFBIG = 240,
    _SC_SS_REPL_MAX = 241,
    _SC_TRACE_EVENT_NAME_MAX = 242,
    _SC_TRACE_NAME_MAX = 243,
    _SC_TRACE_SYS_MAX = 244,
    _SC_TRACE_USER_EVENT_MAX = 245,
    _SC_XOPEN_STREAMS = 246,
    _SC_THREAD_ROBUST_PRIO_INHERIT = 247,
    _SC_THREAD_ROBUST_PRIO_PROTECT = 248,
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed74 {
    _CS_PATH = 0,
    _CS_V6_WIDTH_RESTRICTED_ENVS = 1,
    _CS_GNU_LIBC_VERSION = 2,
    _CS_GNU_LIBPTHREAD_VERSION = 3,
    _CS_V5_WIDTH_RESTRICTED_ENVS = 4,
    _CS_V7_WIDTH_RESTRICTED_ENVS = 5,
    _CS_LFS_CFLAGS = 1000,
    _CS_LFS_LDFLAGS = 1001,
    _CS_LFS_LIBS = 1002,
    _CS_LFS_LINTFLAGS = 1003,
    _CS_LFS64_CFLAGS = 1004,
    _CS_LFS64_LDFLAGS = 1005,
    _CS_LFS64_LIBS = 1006,
    _CS_LFS64_LINTFLAGS = 1007,
    _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
    _CS_XBS5_ILP32_OFF32_LDFLAGS = 1101,
    _CS_XBS5_ILP32_OFF32_LIBS = 1102,
    _CS_XBS5_ILP32_OFF32_LINTFLAGS = 1103,
    _CS_XBS5_ILP32_OFFBIG_CFLAGS = 1104,
    _CS_XBS5_ILP32_OFFBIG_LDFLAGS = 1105,
    _CS_XBS5_ILP32_OFFBIG_LIBS = 1106,
    _CS_XBS5_ILP32_OFFBIG_LINTFLAGS = 1107,
    _CS_XBS5_LP64_OFF64_CFLAGS = 1108,
    _CS_XBS5_LP64_OFF64_LDFLAGS = 1109,
    _CS_XBS5_LP64_OFF64_LIBS = 1110,
    _CS_XBS5_LP64_OFF64_LINTFLAGS = 1111,
    _CS_XBS5_LPBIG_OFFBIG_CFLAGS = 1112,
    _CS_XBS5_LPBIG_OFFBIG_LDFLAGS = 1113,
    _CS_XBS5_LPBIG_OFFBIG_LIBS = 1114,
    _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS = 1115,
    _CS_POSIX_V6_ILP32_OFF32_CFLAGS = 1116,
    _CS_POSIX_V6_ILP32_OFF32_LDFLAGS = 1117,
    _CS_POSIX_V6_ILP32_OFF32_LIBS = 1118,
    _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS = 1119,
    _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS = 1120,
    _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS = 1121,
    _CS_POSIX_V6_ILP32_OFFBIG_LIBS = 1122,
    _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS = 1123,
    _CS_POSIX_V6_LP64_OFF64_CFLAGS = 1124,
    _CS_POSIX_V6_LP64_OFF64_LDFLAGS = 1125,
    _CS_POSIX_V6_LP64_OFF64_LIBS = 1126,
    _CS_POSIX_V6_LP64_OFF64_LINTFLAGS = 1127,
    _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS = 1128,
    _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS = 1129,
    _CS_POSIX_V6_LPBIG_OFFBIG_LIBS = 1130,
    _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS = 1131,
    _CS_POSIX_V7_ILP32_OFF32_CFLAGS = 1132,
    _CS_POSIX_V7_ILP32_OFF32_LDFLAGS = 1133,
    _CS_POSIX_V7_ILP32_OFF32_LIBS = 1134,
    _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS = 1135,
    _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS = 1136,
    _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS = 1137,
    _CS_POSIX_V7_ILP32_OFFBIG_LIBS = 1138,
    _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS = 1139,
    _CS_POSIX_V7_LP64_OFF64_CFLAGS = 1140,
    _CS_POSIX_V7_LP64_OFF64_LDFLAGS = 1141,
    _CS_POSIX_V7_LP64_OFF64_LIBS = 1142,
    _CS_POSIX_V7_LP64_OFF64_LINTFLAGS = 1143,
    _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS = 1144,
    _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS = 1145,
    _CS_POSIX_V7_LPBIG_OFFBIG_LIBS = 1146,
    _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS = 1147,
    _CS_V6_ENV = 1148,
    _CS_V7_ENV = 1149,
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_Unnamed75 {
    SCM_FAILED_CONVERSION_ERROR = 0,
    SCM_FAILED_CONVERSION_QUESTION_MARK = 1,
    SCM_FAILED_CONVERSION_ESCAPE_SEQUENCE = 2,
}
pub type scm_t_string_failed_conversion_handler = Enum_Unnamed75;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_scm_t_port_rw_active {
    SCM_PORT_NEITHER = 0,
    SCM_PORT_READ = 1,
    SCM_PORT_WRITE = 2,
}
pub type scm_t_port_rw_active = Enum_scm_t_port_rw_active;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed76 {
    pub port: SCM,
    pub revealed: c_int,
    pub stream: scm_t_bits,
    pub file_name: SCM,
    pub line_number: c_long,
    pub column_number: c_int,
    pub encoding: *mut c_char,
    pub ilseq_handler: scm_t_string_failed_conversion_handler,
    pub read_buf: *mut c_uchar,
    pub read_pos: *const c_uchar,
    pub read_end: *mut c_uchar,
    pub read_buf_size: scm_t_off,
    pub saved_read_buf: *mut c_uchar,
    pub saved_read_pos: *const c_uchar,
    pub saved_read_end: *mut c_uchar,
    pub saved_read_buf_size: scm_t_off,
    pub write_buf: *mut c_uchar,
    pub write_pos: *mut c_uchar,
    pub write_end: *mut c_uchar,
    pub write_buf_size: scm_t_off,
    pub shortbuf: c_uchar,
    pub rw_random: c_int,
    pub rw_active: scm_t_port_rw_active,
    pub putback_buf: *mut c_uchar,
    pub putback_buf_size: size_t,
    pub input_cd: *mut c_void,
    pub output_cd: *mut c_void,
}
impl ::std::clone::Clone for Struct_Unnamed76 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed76 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_port = Struct_Unnamed76;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_t_ptob_descriptor {
    pub name: *mut c_char,
    pub mark: ::std::option::Option<extern "C" fn(arg1: SCM) -> SCM>,
    pub free: ::std::option::Option<extern "C" fn(arg1: SCM) -> size_t>,
    pub print: ::std::option::Option<unsafe extern "C" fn(exp: SCM, port: SCM,
                                                          pstate:
                                                              *mut scm_print_state)
                                         -> c_int>,
    pub equalp: ::std::option::Option<extern "C" fn(arg1: SCM, arg2: SCM)
                                          -> SCM>,
    pub close: ::std::option::Option<extern "C" fn(port: SCM)
                                         -> c_int>,
    pub write: ::std::option::Option<unsafe extern "C" fn(port: SCM,
                                                          data:
                                                              *const c_void,
                                                          size: size_t)>,
    pub flush: ::std::option::Option<extern "C" fn(port: SCM)>,
    pub end_input: ::std::option::Option<extern "C" fn(port: SCM,
                                                       offset:
                                                           c_int)>,
    pub fill_input: ::std::option::Option<extern "C" fn(port: SCM)
                                              -> c_int>,
    pub input_waiting: ::std::option::Option<extern "C" fn(port: SCM)
                                                 -> c_int>,
    pub seek: ::std::option::Option<extern "C" fn(port: SCM,
                                                  OFFSET: scm_t_off,
                                                  WHENCE:
                                                      c_int)
                                        -> scm_t_off>,
    pub truncate: ::std::option::Option<extern "C" fn(port: SCM,
                                                      length: scm_t_off)>,
}
impl ::std::clone::Clone for Struct_scm_t_ptob_descriptor {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_t_ptob_descriptor {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_ptob_descriptor = Struct_scm_t_ptob_descriptor;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_t_fport {
    pub fdes: c_int,
}
impl ::std::clone::Clone for Struct_scm_t_fport {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_t_fport {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_fport = Struct_scm_t_fport;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_scm_t_c_hook_type {
    SCM_C_HOOK_NORMAL = 0,
    SCM_C_HOOK_OR = 1,
    SCM_C_HOOK_AND = 2,
}
pub type scm_t_c_hook_type = Enum_scm_t_c_hook_type;
pub type scm_t_c_hook_function =
    ::std::option::Option<unsafe extern "C" fn(hook_data:
                                                   *mut c_void,
                                               fn_data:
                                                   *mut c_void,
                                               data:
                                                   *mut c_void)
                              -> *mut c_void>;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_t_c_hook_entry {
    pub next: *mut Struct_scm_t_c_hook_entry,
    pub func: scm_t_c_hook_function,
    pub data: *mut c_void,
}
impl ::std::clone::Clone for Struct_scm_t_c_hook_entry {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_t_c_hook_entry {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_c_hook_entry = Struct_scm_t_c_hook_entry;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_t_c_hook {
    pub first: *mut scm_t_c_hook_entry,
    pub _type: scm_t_c_hook_type,
    pub data: *mut c_void,
}
impl ::std::clone::Clone for Struct_scm_t_c_hook {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_t_c_hook {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_c_hook = Struct_scm_t_c_hook;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_t_cell {
    pub word_0: SCM,
    pub word_1: SCM,
}
impl ::std::clone::Clone for Struct_scm_t_cell {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_t_cell {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_cell = Struct_scm_t_cell;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_t_method {
    pub generic_function: SCM,
    pub specializers: SCM,
    pub procedure: SCM,
}
impl ::std::clone::Clone for Struct_scm_t_method {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_t_method {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_method = Struct_scm_t_method;
pub type scm_t_hash_fn =
    ::std::option::Option<unsafe extern "C" fn(obj: SCM,
                                               max: c_ulong,
                                               closure:
                                                   *mut c_void)
                              -> c_ulong>;
pub type scm_t_assoc_fn =
    ::std::option::Option<unsafe extern "C" fn(obj: SCM, alist: SCM,
                                               closure:
                                                   *mut c_void)
                              -> SCM>;
pub type scm_t_hash_predicate_fn =
    ::std::option::Option<unsafe extern "C" fn(obj: SCM,
                                               closure:
                                                   *mut c_void)
                              -> c_int>;
pub type scm_t_hash_fold_fn =
    ::std::option::Option<unsafe extern "C" fn(closure:
                                                   *mut c_void,
                                               key: SCM, value: SCM,
                                               result: SCM) -> SCM>;
pub type scm_t_hash_handle_fn =
    ::std::option::Option<unsafe extern "C" fn(closure:
                                                   *mut c_void,
                                               handle: SCM) -> SCM>;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_t_hashtable {
    pub flags: c_int,
    pub n_items: c_ulong,
    pub lower: c_ulong,
    pub upper: c_ulong,
    pub size_index: c_int,
    pub min_size_index: c_int,
    pub hash_fn: scm_t_hash_fn,
}
impl ::std::clone::Clone for Struct_scm_t_hashtable {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_t_hashtable {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_hashtable = Struct_scm_t_hashtable;
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum_scm_keyword_arguments_flags {
    SCM_ALLOW_OTHER_KEYS = 1,
    SCM_ALLOW_NON_KEYWORD_ARGUMENTS = 2,
}
pub type scm_t_keyword_arguments_flags = Enum_scm_keyword_arguments_flags;
pub type scm_t_macro_primitive =
    ::std::option::Option<extern "C" fn(arg1: SCM, arg2: SCM) -> SCM>;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_t_rstate {
    pub rng: *mut Struct_scm_t_rng,
    pub normal_next: c_double,
}
impl ::std::clone::Clone for Struct_scm_t_rstate {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_t_rstate {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_rstate = Struct_scm_t_rstate;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_t_rng {
    pub rstate_size: size_t,
    pub random_bits: ::std::option::Option<unsafe extern "C" fn(state:
                                                                    *mut scm_t_rstate)
                                               -> scm_t_uint32>,
    pub init_rstate: ::std::option::Option<unsafe extern "C" fn(state:
                                                                    *mut scm_t_rstate,
                                                                seed:
                                                                    *const c_char,
                                                                n:
                                                                    c_int)>,
    pub copy_rstate: ::std::option::Option<unsafe extern "C" fn(state:
                                                                    *mut scm_t_rstate)
                                               -> *mut scm_t_rstate>,
    pub from_datum: ::std::option::Option<unsafe extern "C" fn(state:
                                                                   *mut scm_t_rstate,
                                                               datum: SCM)>,
    pub to_datum: ::std::option::Option<unsafe extern "C" fn(state:
                                                                 *mut scm_t_rstate)
                                            -> SCM>,
}
impl ::std::clone::Clone for Struct_scm_t_rng {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_t_rng {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_rng = Struct_scm_t_rng;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_smob_descriptor {
    pub name: *const c_char,
    pub size: size_t,
    pub mark: ::std::option::Option<extern "C" fn(arg1: SCM) -> SCM>,
    pub free: ::std::option::Option<extern "C" fn(arg1: SCM) -> size_t>,
    pub print: ::std::option::Option<unsafe extern "C" fn(exp: SCM, port: SCM,
                                                          pstate:
                                                              *mut scm_print_state)
                                         -> c_int>,
    pub equalp: ::std::option::Option<extern "C" fn(arg1: SCM, arg2: SCM)
                                          -> SCM>,
    pub apply: scm_t_subr,
    pub apply_trampoline_objcode: SCM,
}
impl ::std::clone::Clone for Struct_scm_smob_descriptor {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_smob_descriptor {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_smob_descriptor = Struct_scm_smob_descriptor;
pub enum Struct_sockaddr { }
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed77 {
    pub lo: scm_t_wchar,
    pub hi: scm_t_wchar,
}
impl ::std::clone::Clone for Struct_Unnamed77 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed77 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_char_range = Struct_Unnamed77;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed78 {
    pub len: size_t,
    pub ranges: *mut scm_t_char_range,
}
impl ::std::clone::Clone for Struct_Unnamed78 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed78 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_char_set = Struct_Unnamed78;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed79 {
    pub range: size_t,
    pub n: scm_t_wchar,
}
impl ::std::clone::Clone for Struct_Unnamed79 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed79 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type scm_t_char_set_cursor = Struct_Unnamed79;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_objcode {
    pub len: scm_t_uint32,
    pub metalen: scm_t_uint32,
}
impl ::std::clone::Clone for Struct_scm_objcode {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_objcode {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_vm_frame {
    pub dynamic_link: *mut SCM,
    pub mv_return_address: *mut scm_t_uint8,
    pub return_address: *mut scm_t_uint8,
    pub program: SCM,
    pub stack: [SCM; 1usize],
}
impl ::std::clone::Clone for Struct_scm_vm_frame {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_vm_frame {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct_scm_frame {
    pub stack_holder: SCM,
    pub fp: *mut SCM,
    pub sp: *mut SCM,
    pub ip: *mut scm_t_uint8,
    pub offset: scm_t_ptrdiff,
}
impl ::std::clone::Clone for Struct_scm_frame {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_scm_frame {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type FILE = Struct__IO_FILE;
pub type __FILE = Struct__IO_FILE;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed80 {
    pub __count: c_int,
    pub __value: Union_Unnamed81,
}
impl ::std::clone::Clone for Struct_Unnamed80 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed80 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Copy)]
pub struct Union_Unnamed81 {
    pub _bindgen_data_: [u32; 1usize],
}
impl Union_Unnamed81 {
    pub unsafe fn __wch(&mut self) -> *mut 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 [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_Unnamed81 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Union_Unnamed81 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type __mbstate_t = Struct_Unnamed80;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed82 {
    pub __pos: __off_t,
    pub __state: __mbstate_t,
}
impl ::std::clone::Clone for Struct_Unnamed82 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed82 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type _G_fpos_t = Struct_Unnamed82;
#[repr(C)]
#[derive(Copy)]
pub struct Struct_Unnamed83 {
    pub __pos: __off64_t,
    pub __state: __mbstate_t,
}
impl ::std::clone::Clone for Struct_Unnamed83 {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct_Unnamed83 {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type _G_fpos64_t = Struct_Unnamed83;
pub type va_list = __gnuc_va_list;
pub type __gnuc_va_list = __builtin_va_list;
pub enum Struct__IO_jump_t { }
pub type _IO_lock_t = 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: 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() } }
}
#[derive(Clone, Copy)]
#[repr(u32)]
pub enum Enum___codecvt_result {
    __codecvt_ok = 0,
    __codecvt_partial = 1,
    __codecvt_error = 2,
    __codecvt_noconv = 3,
}
#[repr(C)]
#[derive(Copy)]
pub struct Struct__IO_FILE {
    pub _flags: c_int,
    pub _IO_read_ptr: *mut c_char,
    pub _IO_read_end: *mut c_char,
    pub _IO_read_base: *mut c_char,
    pub _IO_write_base: *mut c_char,
    pub _IO_write_ptr: *mut c_char,
    pub _IO_write_end: *mut c_char,
    pub _IO_buf_base: *mut c_char,
    pub _IO_buf_end: *mut c_char,
    pub _IO_save_base: *mut c_char,
    pub _IO_backup_base: *mut c_char,
    pub _IO_save_end: *mut c_char,
    pub _markers: *mut Struct__IO_marker,
    pub _chain: *mut Struct__IO_FILE,
    pub _fileno: c_int,
    pub _flags2: c_int,
    pub _old_offset: __off_t,
    pub _cur_column: c_ushort,
    pub _vtable_offset: c_char,
    pub _shortbuf: [c_char; 1usize],
    pub _lock: *mut _IO_lock_t,
    pub _offset: __off64_t,
    pub __pad1: *mut c_void,
    pub __pad2: *mut c_void,
    pub __pad3: *mut c_void,
    pub __pad4: *mut c_void,
    pub __pad5: size_t,
    pub _mode: c_int,
    pub _unused2: [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 =
    unsafe extern "C" fn(__cookie: *mut c_void,
                         __buf: *mut c_char, __nbytes: size_t)
        -> __ssize_t;
pub type __io_write_fn =
    unsafe extern "C" fn(__cookie: *mut c_void,
                         __buf: *const c_char, __n: size_t)
        -> __ssize_t;
pub type __io_seek_fn =
    unsafe extern "C" fn(__cookie: *mut c_void,
                         __pos: *mut __off64_t, __w: c_int)
        -> c_int;
pub type __io_close_fn =
    unsafe extern "C" fn(__cookie: *mut c_void)
        -> c_int;
pub type fpos_t = _G_fpos_t;
pub type scm_t_inner =
    ::std::option::Option<unsafe extern "C" fn(arg1:
                                                   *mut c_void)
                              -> SCM>;
pub type scm_t_array = scm_i_t_array;
pub type __builtin_va_list = [__va_list_tag; 1usize];
pub type __va_list_tag = Struct___va_list_tag;
#[repr(C)]
#[derive(Copy)]
pub struct Struct___va_list_tag {
    pub gp_offset: c_uint,
    pub fp_offset: c_uint,
    pub overflow_arg_area: *mut c_void,
    pub reg_save_area: *mut c_void,
}
impl ::std::clone::Clone for Struct___va_list_tag {
    fn clone(&self) -> Self { *self }
}
impl ::std::default::Default for Struct___va_list_tag {
    fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[link(name = "guile-2.0")]
extern "C" {
    pub static __gmp_bits_per_limb: c_int;
    pub static mut __gmp_errno: c_int;
    pub static __gmp_version: *const c_char;
    pub static mut __tzname: [*mut c_char; 2usize];
    pub static mut __daylight: c_int;
    pub static mut __timezone: c_long;
    pub static mut tzname: [*mut c_char; 2usize];
    pub static mut daylight: c_int;
    pub static mut timezone: c_long;
    pub static mut scm_system_error_key: SCM;
    pub static mut scm_num_overflow_key: SCM;
    pub static mut scm_out_of_range_key: SCM;
    pub static mut scm_args_number_key: SCM;
    pub static mut scm_arg_type_key: SCM;
    pub static mut scm_memory_alloc_key: SCM;
    pub static mut scm_misc_error_key: SCM;
    pub static mut scm_print_state_vtable: SCM;
    pub static mut scm_tc16_port_with_ps: scm_t_bits;
    pub static mut scm_install_gmp_memory_functions: c_int;
    pub static mut scm_i_array_element_types: *mut SCM;
    pub static mut scm_sym_documentation: SCM;
    pub static mut GC_gc_no: GC_word;
    pub static mut GC_parallel: c_int;
    pub static mut GC_oom_fn: GC_oom_func;
    pub static mut GC_on_heap_resize: GC_on_heap_resize_proc;
    pub static mut GC_find_leak: c_int;
    pub static mut GC_all_interior_pointers: c_int;
    pub static mut GC_finalize_on_demand: c_int;
    pub static mut GC_java_finalization: c_int;
    pub static mut GC_finalizer_notifier: GC_finalizer_notifier_proc;
    pub static mut GC_dont_gc: c_int;
    pub static mut GC_dont_expand: c_int;
    pub static mut GC_use_entire_heap: c_int;
    pub static mut GC_full_freq: c_int;
    pub static mut GC_non_gc_bytes: GC_word;
    pub static mut GC_no_dls: c_int;
    pub static mut GC_free_space_divisor: GC_word;
    pub static mut GC_max_retries: GC_word;
    pub static mut GC_stackbottom: *mut c_char;
    pub static mut GC_dont_precollect: c_int;
    pub static mut GC_time_limit: c_ulong;
    pub static mut GC_same_obj_print_proc:
               ::std::option::Option<unsafe extern "C" fn(arg1:
                                                              *mut c_void,
                                                          arg2:
                                                              *mut c_void)>;
    pub static mut GC_is_valid_displacement_print_proc:
               ::std::option::Option<unsafe extern "C" fn(arg1:
                                                              *mut c_void)>;
    pub static mut GC_is_visible_print_proc:
               ::std::option::Option<unsafe extern "C" fn(arg1:
                                                              *mut c_void)>;
    pub static mut _sys_siglist: [*const c_char; 65usize];
    pub static mut sys_siglist: [*const c_char; 65usize];
    pub static mut scm_i_pthread_mutexattr_recursive:
               [pthread_mutexattr_t; 1usize];
    pub static mut scm_tc16_thread: scm_t_bits;
    pub static mut scm_tc16_mutex: scm_t_bits;
    pub static mut scm_tc16_condvar: scm_t_bits;
    pub static mut scm_i_misc_mutex: pthread_mutex_t;
    pub static mut scm_i_critical_section_mutex: pthread_mutex_t;
    pub static mut scm_endianness_big: SCM;
    pub static mut scm_endianness_little: SCM;
    pub static mut scm_i_native_endianness: SCM;
    pub static mut scm_null_bytevector: SCM;
    pub static mut scm_standard_vtable_vtable: SCM;
    pub static mut scm_applicable_struct_vtable_vtable: SCM;
    pub static mut scm_applicable_struct_with_setter_vtable_vtable: SCM;
    pub static mut scm_sym_and: SCM;
    pub static mut scm_sym_begin: SCM;
    pub static mut scm_sym_case: SCM;
    pub static mut scm_sym_cond: SCM;
    pub static mut scm_sym_define: SCM;
    pub static mut scm_sym_do: SCM;
    pub static mut scm_sym_if: SCM;
    pub static mut scm_sym_lambda: SCM;
    pub static mut scm_sym_let: SCM;
    pub static mut scm_sym_letstar: SCM;
    pub static mut scm_sym_letrec: SCM;
    pub static mut scm_sym_quote: SCM;
    pub static mut scm_sym_quasiquote: SCM;
    pub static mut scm_sym_unquote: SCM;
    pub static mut scm_sym_uq_splicing: SCM;
    pub static mut scm_sym_with_fluids: SCM;
    pub static mut scm_sym_at: SCM;
    pub static mut scm_sym_atat: SCM;
    pub static mut scm_sym_atapply: SCM;
    pub static mut scm_sym_atcall_cc: SCM;
    pub static mut scm_sym_at_call_with_values: SCM;
    pub static mut scm_sym_at_prompt: SCM;
    pub static mut scm_sym_delay: SCM;
    pub static mut scm_sym_at_dynamic_wind: SCM;
    pub static mut scm_sym_eval_when: SCM;
    pub static mut scm_sym_arrow: SCM;
    pub static mut scm_sym_else: SCM;
    pub static mut scm_sym_apply: SCM;
    pub static mut scm_sym_set_x: SCM;
    pub static mut scm_sym_args: SCM;
    pub static mut scm_tc16_memoized: scm_t_bits;
    pub static mut scm_program_arguments_fluid: SCM;
    pub static mut scm_tc16_dir: scm_t_bits;
    pub static mut __environ: *mut *mut c_char;
    pub static mut optarg: *mut c_char;
    pub static mut optind: c_int;
    pub static mut opterr: c_int;
    pub static mut optopt: c_int;
    pub static mut scm_nullstr: SCM;
    pub static mut scm_i_port_table_mutex: pthread_mutex_t;
    pub static mut scm_i_port_weak_hash: SCM;
    pub static mut scm_ptobs: *mut scm_t_ptob_descriptor;
    pub static mut scm_numptob: c_long;
    pub static mut scm_tc16_fport: scm_t_bits;
    pub static mut scm_tc16_hook: scm_t_bits;
    pub static mut scm_i_gc_admin_mutex: pthread_mutex_t;
    pub static mut scm_i_sweep_mutex: pthread_mutex_t;
    pub static mut scm_default_init_heap_size_1: size_t;
    pub static mut scm_default_min_yield_1: c_int;
    pub static mut scm_default_init_heap_size_2: size_t;
    pub static mut scm_default_min_yield_2: c_int;
    pub static mut scm_default_max_segment_size: size_t;
    pub static mut scm_gc_ports_collected: c_ulong;
    pub static mut scm_after_gc_hook: SCM;
    pub static mut scm_before_gc_c_hook: scm_t_c_hook;
    pub static mut scm_before_mark_c_hook: scm_t_c_hook;
    pub static mut scm_before_sweep_c_hook: scm_t_c_hook;
    pub static mut scm_after_sweep_c_hook: scm_t_c_hook;
    pub static mut scm_after_gc_c_hook: scm_t_c_hook;
    pub static mut scm_protects: SCM;
    pub static mut scm_print_carefully_p: c_int;
    pub static mut scm_class_boolean: SCM;
    pub static mut scm_class_char: SCM;
    pub static mut scm_class_pair: SCM;
    pub static mut scm_class_procedure: SCM;
    pub static mut scm_class_string: SCM;
    pub static mut scm_class_symbol: SCM;
    pub static mut scm_class_primitive_generic: SCM;
    pub static mut scm_class_vector: SCM;
    pub static mut scm_class_null: SCM;
    pub static mut scm_class_real: SCM;
    pub static mut scm_class_complex: SCM;
    pub static mut scm_class_integer: SCM;
    pub static mut scm_class_fraction: SCM;
    pub static mut scm_class_unknown: SCM;
    pub static mut scm_port_class: *mut SCM;
    pub static mut scm_smob_class: *mut SCM;
    pub static mut scm_class_top: SCM;
    pub static mut scm_class_object: SCM;
    pub static mut scm_class_class: SCM;
    pub static mut scm_class_applicable: SCM;
    pub static mut scm_class_applicable_struct: SCM;
    pub static mut scm_class_applicable_struct_with_setter: SCM;
    pub static mut scm_class_generic: SCM;
    pub static mut scm_class_generic_with_setter: SCM;
    pub static mut scm_class_accessor: SCM;
    pub static mut scm_class_extended_generic: SCM;
    pub static mut scm_class_extended_generic_with_setter: SCM;
    pub static mut scm_class_extended_accessor: SCM;
    pub static mut scm_class_method: SCM;
    pub static mut scm_class_accessor_method: SCM;
    pub static mut scm_class_procedure_class: SCM;
    pub static mut scm_class_applicable_struct_class: SCM;
    pub static mut scm_class_number: SCM;
    pub static mut scm_class_list: SCM;
    pub static mut scm_class_keyword: SCM;
    pub static mut scm_class_port: SCM;
    pub static mut scm_class_input_output_port: SCM;
    pub static mut scm_class_input_port: SCM;
    pub static mut scm_class_output_port: SCM;
    pub static mut scm_class_foreign_slot: SCM;
    pub static mut scm_class_self: SCM;
    pub static mut scm_class_protected: SCM;
    pub static mut scm_class_hidden: SCM;
    pub static mut scm_class_opaque: SCM;
    pub static mut scm_class_read_only: SCM;
    pub static mut scm_class_protected_hidden: SCM;
    pub static mut scm_class_protected_opaque: SCM;
    pub static mut scm_class_protected_read_only: SCM;
    pub static mut scm_class_scm: SCM;
    pub static mut scm_class_int: SCM;
    pub static mut scm_class_float: SCM;
    pub static mut scm_class_double: SCM;
    pub static mut scm_s_slot_set_x: *const c_char;
    pub static mut scm_no_applicable_method: SCM;
    pub static mut scm_module_goops: SCM;
    pub static mut scm_global_locale: SCM;
    pub static mut scm_i_init_mutex: pthread_mutex_t;
    pub static mut scm_initialized_p: c_int;
    pub static mut scm_tc16_keyword: scm_t_bits;
    pub static mut scm_tc16_malloc: scm_t_bits;
    pub static mut scm_module_system_booted_p: c_int;
    pub static mut scm_module_tag: scm_t_bits;
    pub static mut scm_i_locale_mutex: pthread_mutex_t;
    pub static mut scm_sym_name: SCM;
    pub static mut scm_sym_arity: SCM;
    pub static mut scm_sym_system_procedure: SCM;
    pub static mut scm_tc16_promise: scm_t_bits;
    pub static mut scm_the_rng: scm_t_rng;
    pub static mut scm_tc16_rstate: scm_t_bits;
    pub static mut scm_masktab: [c_uchar; 256usize];
    pub static mut scm_var_random_state: SCM;
    pub static mut scm_sym_dot: SCM;
    pub static mut scm_i_signal_delivery_thread: *mut scm_i_thread;
    pub static mut scm_usage_name: *mut c_char;
    pub static mut scm_numsmob: c_long;
    pub static mut scm_smobs: *mut scm_smob_descriptor;
    pub static mut scm_tc16_srcprops: scm_t_bits;
    pub static mut scm_sym_filename: SCM;
    pub static mut scm_sym_copy: SCM;
    pub static mut scm_sym_line: SCM;
    pub static mut scm_sym_column: SCM;
    pub static mut scm_stack_checking_enabled_p: c_int;
    pub static mut scm_c_time_units_per_second: c_long;
    pub static mut scm_tc16_charset: c_int;
    pub static mut scm_char_set_lower_case: SCM;
    pub static mut scm_char_set_upper_case: SCM;
    pub static mut scm_char_set_title_case: SCM;
    pub static mut scm_char_set_letter: SCM;
    pub static mut scm_char_set_digit: SCM;
    pub static mut scm_char_set_letter_and_digit: SCM;
    pub static mut scm_char_set_graphic: SCM;
    pub static mut scm_char_set_printing: SCM;
    pub static mut scm_char_set_whitespace: SCM;
    pub static mut scm_char_set_iso_control: SCM;
    pub static mut scm_char_set_punctuation: SCM;
    pub static mut scm_char_set_symbol: SCM;
    pub static mut scm_char_set_hex_digit: SCM;
    pub static mut scm_char_set_blank: SCM;
    pub static mut scm_char_set_ascii: SCM;
    pub static mut scm_char_set_empty: SCM;
    pub static mut scm_char_set_full: SCM;
    pub static mut scm_tc16_strport: scm_t_bits;
    pub static mut scm_i_array_element_type_sizes: *const size_t;
    pub static mut scm_values_vtable: SCM;
    pub static mut scm_stack_type: SCM;
    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: c_int;
    pub static mut sys_errlist: *const *const c_char;
    pub static mut scm_isymnames: *mut *mut c_char;
    pub static mut scm_mallocated: c_ulong;
    pub static mut scm_mtrigger: c_ulong;
    pub static mut scm_max_segment_size: size_t;
    pub static mut scm_struct_table: SCM;
    pub static mut scm_tc16_eval_closure: scm_t_bits;
}
#[link(name = "guile-2.0")]
extern "C" {
    pub fn __gmp_set_memory_functions(arg1:
                                          ::std::option::Option<extern "C" fn(arg1:
                                                                                  size_t)
                                                                    ->
                                                                        *mut c_void>,
                                      arg2:
                                          ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                                         *mut c_void,
                                                                                     arg2:
                                                                                         size_t,
                                                                                     arg3:
                                                                                         size_t)
                                                                    ->
                                                                        *mut c_void>,
                                      arg3:
                                          ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                                         *mut c_void,
                                                                                     arg2:
                                                                                         size_t)>);
    pub fn __gmp_get_memory_functions(arg1:
                                          *mut ::std::option::Option<extern "C" fn(arg1:
                                                                                       size_t)
                                                                         ->
                                                                             *mut c_void>,
                                      arg2:
                                          *mut ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                                              *mut c_void,
                                                                                          arg2:
                                                                                              size_t,
                                                                                          arg3:
                                                                                              size_t)
                                                                         ->
                                                                             *mut c_void>,
                                      arg3:
                                          *mut ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                                              *mut c_void,
                                                                                          arg2:
                                                                                              size_t)>);
    pub fn __gmp_randinit(arg1: gmp_randstate_t, arg2: gmp_randalg_t, ...);
    pub fn __gmp_randinit_default(arg1: gmp_randstate_t);
    pub fn __gmp_randinit_lc_2exp(arg1: gmp_randstate_t, arg2: mpz_srcptr,
                                  arg3: c_ulong,
                                  arg4: mp_bitcnt_t);
    pub fn __gmp_randinit_lc_2exp_size(arg1: gmp_randstate_t,
                                       arg2: mp_bitcnt_t)
     -> c_int;
    pub fn __gmp_randinit_mt(arg1: gmp_randstate_t);
    pub fn __gmp_randinit_set(arg1: gmp_randstate_t,
                              arg2: *const __gmp_randstate_struct);
    pub fn __gmp_randseed(arg1: gmp_randstate_t, arg2: mpz_srcptr);
    pub fn __gmp_randseed_ui(arg1: gmp_randstate_t,
                             arg2: c_ulong);
    pub fn __gmp_randclear(arg1: gmp_randstate_t);
    pub fn __gmp_urandomb_ui(arg1: gmp_randstate_t,
                             arg2: c_ulong)
     -> c_ulong;
    pub fn __gmp_urandomm_ui(arg1: gmp_randstate_t,
                             arg2: c_ulong)
     -> c_ulong;
    pub fn __gmp_asprintf(arg1: *mut *mut c_char,
                          arg2: *const c_char, ...)
     -> c_int;
    pub fn __gmp_printf(arg1: *const c_char, ...)
     -> c_int;
    pub fn __gmp_snprintf(arg1: *mut c_char, arg2: size_t,
                          arg3: *const c_char, ...)
     -> c_int;
    pub fn __gmp_sprintf(arg1: *mut c_char,
                         arg2: *const c_char, ...)
     -> c_int;
    pub fn __gmp_scanf(arg1: *const c_char, ...)
     -> c_int;
    pub fn __gmp_sscanf(arg1: *const c_char,
                        arg2: *const c_char, ...)
     -> c_int;
    pub fn __gmpz_realloc(arg1: mpz_ptr, arg2: mp_size_t)
     -> *mut c_void;
    pub fn __gmpz_abs(__gmp_w: mpz_ptr, __gmp_u: mpz_srcptr);
    pub fn __gmpz_add(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
    pub fn __gmpz_add_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
                         arg3: c_ulong);
    pub fn __gmpz_addmul(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
    pub fn __gmpz_addmul_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
                            arg3: c_ulong);
    pub fn __gmpz_and(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
    pub fn __gmpz_array_init(arg1: mpz_ptr, arg2: mp_size_t, arg3: mp_size_t);
    pub fn __gmpz_bin_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
                         arg3: c_ulong);
    pub fn __gmpz_bin_uiui(arg1: mpz_ptr, arg2: c_ulong,
                           arg3: c_ulong);
    pub fn __gmpz_cdiv_q(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
    pub fn __gmpz_cdiv_q_2exp(arg1: mpz_ptr, arg2: mpz_srcptr,
                              arg3: mp_bitcnt_t);
    pub fn __gmpz_cdiv_q_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
                            arg3: c_ulong)
     -> c_ulong;
    pub fn __gmpz_cdiv_qr(arg1: mpz_ptr, arg2: mpz_ptr, arg3: mpz_srcptr,
                          arg4: mpz_srcptr);
    pub fn __gmpz_cdiv_qr_ui(arg1: mpz_ptr, arg2: mpz_ptr, arg3: mpz_srcptr,
                             arg4: c_ulong)
     -> c_ulong;
    pub fn __gmpz_cdiv_r(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
    pub fn __gmpz_cdiv_r_2exp(arg1: mpz_ptr, arg2: mpz_srcptr,
                              arg3: mp_bitcnt_t);
    pub fn __gmpz_cdiv_r_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
                            arg3: c_ulong)
     -> c_ulong;
    pub fn __gmpz_cdiv_ui(arg1: mpz_srcptr, arg2: c_ulong)
     -> c_ulong;
    pub fn __gmpz_clear(arg1: mpz_ptr);
    pub fn __gmpz_clears(arg1: mpz_ptr, ...);
    pub fn __gmpz_clrbit(arg1: mpz_ptr, arg2: mp_bitcnt_t);
    pub fn __gmpz_cmp(arg1: mpz_srcptr, arg2: mpz_srcptr)
     -> c_int;
    pub fn __gmpz_cmp_d(arg1: mpz_srcptr, arg2: c_double)
     -> c_int;
    pub fn __gmpz_cmp_si(arg1: mpz_srcptr, arg2: c_long)
     -> c_int;
    pub fn __gmpz_cmp_ui(arg1: mpz_srcptr, arg2: c_ulong)
     -> c_int;
    pub fn __gmpz_cmpabs(arg1: mpz_srcptr, arg2: mpz_srcptr)
     -> c_int;
    pub fn __gmpz_cmpabs_d(arg1: mpz_srcptr, arg2: c_double)
     -> c_int;
    pub fn __gmpz_cmpabs_ui(arg1: mpz_srcptr, arg2: c_ulong)
     -> c_int;
    pub fn __gmpz_com(arg1: mpz_ptr, arg2: mpz_srcptr);
    pub fn __gmpz_combit(arg1: mpz_ptr, arg2: mp_bitcnt_t);
    pub fn __gmpz_congruent_p(arg1: mpz_srcptr, arg2: mpz_srcptr,
                              arg3: mpz_srcptr) -> c_int;
    pub fn __gmpz_congruent_2exp_p(arg1: mpz_srcptr, arg2: mpz_srcptr,
                                   arg3: mp_bitcnt_t)
     -> c_int;
    pub fn __gmpz_congruent_ui_p(arg1: mpz_srcptr,
                                 arg2: c_ulong,
                                 arg3: c_ulong)
     -> c_int;
    pub fn __gmpz_divexact(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
    pub fn __gmpz_divexact_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
                              arg3: c_ulong);
    pub fn __gmpz_divisible_p(arg1: mpz_srcptr, arg2: mpz_srcptr)
     -> c_int;
    pub fn __gmpz_divisible_ui_p(arg1: mpz_srcptr,
                                 arg2: c_ulong)
     -> c_int;
    pub fn __gmpz_divisible_2exp_p(arg1: mpz_srcptr, arg2: mp_bitcnt_t)
     -> c_int;
    pub fn __gmpz_dump(arg1: mpz_srcptr);
    pub fn __gmpz_export(arg1: *mut c_void, arg2: *mut size_t,
                         arg3: c_int, arg4: size_t,
                         arg5: c_int, arg6: size_t,
                         arg7: mpz_srcptr) -> *mut c_void;
    pub fn __gmpz_fac_ui(arg1: mpz_ptr, arg2: c_ulong);
    pub fn __gmpz_2fac_ui(arg1: mpz_ptr, arg2: c_ulong);
    pub fn __gmpz_mfac_uiui(arg1: mpz_ptr, arg2: c_ulong,
                            arg3: c_ulong);
    pub fn __gmpz_primorial_ui(arg1: mpz_ptr, arg2: c_ulong);
    pub fn __gmpz_fdiv_q(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
    pub fn __gmpz_fdiv_q_2exp(arg1: mpz_ptr, arg2: mpz_srcptr,
                              arg3: mp_bitcnt_t);
    pub fn __gmpz_fdiv_q_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
                            arg3: c_ulong)
     -> c_ulong;
    pub fn __gmpz_fdiv_qr(arg1: mpz_ptr, arg2: mpz_ptr, arg3: mpz_srcptr,
                          arg4: mpz_srcptr);
    pub fn __gmpz_fdiv_qr_ui(arg1: mpz_ptr, arg2: mpz_ptr, arg3: mpz_srcptr,
                             arg4: c_ulong)
     -> c_ulong;
    pub fn __gmpz_fdiv_r(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
    pub fn __gmpz_fdiv_r_2exp(arg1: mpz_ptr, arg2: mpz_srcptr,
                              arg3: mp_bitcnt_t);
    pub fn __gmpz_fdiv_r_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
                            arg3: c_ulong)
     -> c_ulong;
    pub fn __gmpz_fdiv_ui(arg1: mpz_srcptr, arg2: c_ulong)
     -> c_ulong;
    pub fn __gmpz_fib_ui(arg1: mpz_ptr, arg2: c_ulong);
    pub fn __gmpz_fib2_ui(arg1: mpz_ptr, arg2: mpz_ptr,
                          arg3: c_ulong);
    pub fn __gmpz_fits_sint_p(arg1: mpz_srcptr) -> c_int;
    pub fn __gmpz_fits_slong_p(arg1: mpz_srcptr) -> c_int;
    pub fn __gmpz_fits_sshort_p(arg1: mpz_srcptr) -> c_int;
    pub fn __gmpz_fits_uint_p(__gmp_z: mpz_srcptr) -> c_int;
    pub fn __gmpz_fits_ulong_p(__gmp_z: mpz_srcptr) -> c_int;
    pub fn __gmpz_fits_ushort_p(__gmp_z: mpz_srcptr) -> c_int;
    pub fn __gmpz_gcd(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
    pub fn __gmpz_gcd_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
                         arg3: c_ulong)
     -> c_ulong;
    pub fn __gmpz_gcdext(arg1: mpz_ptr, arg2: mpz_ptr, arg3: mpz_ptr,
                         arg4: mpz_srcptr, arg5: mpz_srcptr);
    pub fn __gmpz_get_d(arg1: mpz_srcptr) -> c_double;
    pub fn __gmpz_get_d_2exp(arg1: *mut c_long,
                             arg2: mpz_srcptr) -> c_double;
    pub fn __gmpz_get_si(arg1: mpz_srcptr) -> c_long;
    pub fn __gmpz_get_str(arg1: *mut c_char,
                          arg2: c_int, arg3: mpz_srcptr)
     -> *mut c_char;
    pub fn __gmpz_get_ui(__gmp_z: mpz_srcptr) -> c_ulong;
    pub fn __gmpz_getlimbn(__gmp_z: mpz_srcptr, __gmp_n: mp_size_t)
     -> mp_limb_t;
    pub fn __gmpz_hamdist(arg1: mpz_srcptr, arg2: mpz_srcptr) -> mp_bitcnt_t;
    pub fn __gmpz_import(arg1: mpz_ptr, arg2: size_t,
                         arg3: c_int, arg4: size_t,
                         arg5: c_int, arg6: size_t,
                         arg7: *const c_void);
    pub fn __gmpz_init(arg1: mpz_ptr);
    pub fn __gmpz_init2(arg1: mpz_ptr, arg2: mp_bitcnt_t);
    pub fn __gmpz_inits(arg1: mpz_ptr, ...);
    pub fn __gmpz_init_set(arg1: mpz_ptr, arg2: mpz_srcptr);
    pub fn __gmpz_init_set_d(arg1: mpz_ptr, arg2: c_double);
    pub fn __gmpz_init_set_si(arg1: mpz_ptr, arg2: c_long);
    pub fn __gmpz_init_set_str(arg1: mpz_ptr,
                               arg2: *const c_char,
                               arg3: c_int)
     -> c_int;
    pub fn __gmpz_init_set_ui(arg1: mpz_ptr, arg2: c_ulong);
    pub fn __gmpz_invert(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr)
     -> c_int;
    pub fn __gmpz_ior(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
    pub fn __gmpz_jacobi(arg1: mpz_srcptr, arg2: mpz_srcptr)
     -> c_int;
    pub fn __gmpz_kronecker_si(arg1: mpz_srcptr, arg2: c_long)
     -> c_int;
    pub fn __gmpz_kronecker_ui(arg1: mpz_srcptr,
                               arg2: c_ulong)
     -> c_int;
    pub fn __gmpz_si_kronecker(arg1: c_long, arg2: mpz_srcptr)
     -> c_int;
    pub fn __gmpz_ui_kronecker(arg1: c_ulong,
                               arg2: mpz_srcptr) -> c_int;
    pub fn __gmpz_lcm(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
    pub fn __gmpz_lcm_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
                         arg3: c_ulong);
    pub fn __gmpz_lucnum_ui(arg1: mpz_ptr, arg2: c_ulong);
    pub fn __gmpz_lucnum2_ui(arg1: mpz_ptr, arg2: mpz_ptr,
                             arg3: c_ulong);
    pub fn __gmpz_millerrabin(arg1: mpz_srcptr, arg2: c_int)
     -> c_int;
    pub fn __gmpz_mod(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
    pub fn __gmpz_mul(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
    pub fn __gmpz_mul_2exp(arg1: mpz_ptr, arg2: mpz_srcptr,
                           arg3: mp_bitcnt_t);
    pub fn __gmpz_mul_si(arg1: mpz_ptr, arg2: mpz_srcptr,
                         arg3: c_long);
    pub fn __gmpz_mul_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
                         arg3: c_ulong);
    pub fn __gmpz_neg(__gmp_w: mpz_ptr, __gmp_u: mpz_srcptr);
    pub fn __gmpz_nextprime(arg1: mpz_ptr, arg2: mpz_srcptr);
    pub fn __gmpz_perfect_power_p(arg1: mpz_srcptr) -> c_int;
    pub fn __gmpz_perfect_square_p(__gmp_a: mpz_srcptr)
     -> c_int;
    pub fn __gmpz_popcount(__gmp_u: mpz_srcptr) -> mp_bitcnt_t;
    pub fn __gmpz_pow_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
                         arg3: c_ulong);
    pub fn __gmpz_powm(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr,
                       arg4: mpz_srcptr);
    pub fn __gmpz_powm_sec(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr,
                           arg4: mpz_srcptr);
    pub fn __gmpz_powm_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
                          arg3: c_ulong, arg4: mpz_srcptr);
    pub fn __gmpz_probab_prime_p(arg1: mpz_srcptr,
                                 arg2: c_int)
     -> c_int;
    pub fn __gmpz_random(arg1: mpz_ptr, arg2: mp_size_t);
    pub fn __gmpz_random2(arg1: mpz_ptr, arg2: mp_size_t);
    pub fn __gmpz_realloc2(arg1: mpz_ptr, arg2: mp_bitcnt_t);
    pub fn __gmpz_remove(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr)
     -> mp_bitcnt_t;
    pub fn __gmpz_root(arg1: mpz_ptr, arg2: mpz_srcptr,
                       arg3: c_ulong)
     -> c_int;
    pub fn __gmpz_rootrem(arg1: mpz_ptr, arg2: mpz_ptr, arg3: mpz_srcptr,
                          arg4: c_ulong);
    pub fn __gmpz_rrandomb(arg1: mpz_ptr, arg2: gmp_randstate_t,
                           arg3: mp_bitcnt_t);
    pub fn __gmpz_scan0(arg1: mpz_srcptr, arg2: mp_bitcnt_t) -> mp_bitcnt_t;
    pub fn __gmpz_scan1(arg1: mpz_srcptr, arg2: mp_bitcnt_t) -> mp_bitcnt_t;
    pub fn __gmpz_set(arg1: mpz_ptr, arg2: mpz_srcptr);
    pub fn __gmpz_set_d(arg1: mpz_ptr, arg2: c_double);
    pub fn __gmpz_set_f(arg1: mpz_ptr, arg2: mpf_srcptr);
    pub fn __gmpz_set_q(__gmp_w: mpz_ptr, __gmp_u: mpq_srcptr);
    pub fn __gmpz_set_si(arg1: mpz_ptr, arg2: c_long);
    pub fn __gmpz_set_str(arg1: mpz_ptr, arg2: *const c_char,
                          arg3: c_int)
     -> c_int;
    pub fn __gmpz_set_ui(arg1: mpz_ptr, arg2: c_ulong);
    pub fn __gmpz_setbit(arg1: mpz_ptr, arg2: mp_bitcnt_t);
    pub fn __gmpz_size(__gmp_z: mpz_srcptr) -> size_t;
    pub fn __gmpz_sizeinbase(arg1: mpz_srcptr, arg2: c_int)
     -> size_t;
    pub fn __gmpz_sqrt(arg1: mpz_ptr, arg2: mpz_srcptr);
    pub fn __gmpz_sqrtrem(arg1: mpz_ptr, arg2: mpz_ptr, arg3: mpz_srcptr);
    pub fn __gmpz_sub(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
    pub fn __gmpz_sub_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
                         arg3: c_ulong);
    pub fn __gmpz_ui_sub(arg1: mpz_ptr, arg2: c_ulong,
                         arg3: mpz_srcptr);
    pub fn __gmpz_submul(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
    pub fn __gmpz_submul_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
                            arg3: c_ulong);
    pub fn __gmpz_swap(arg1: mpz_ptr, arg2: mpz_ptr);
    pub fn __gmpz_tdiv_ui(arg1: mpz_srcptr, arg2: c_ulong)
     -> c_ulong;
    pub fn __gmpz_tdiv_q(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
    pub fn __gmpz_tdiv_q_2exp(arg1: mpz_ptr, arg2: mpz_srcptr,
                              arg3: mp_bitcnt_t);
    pub fn __gmpz_tdiv_q_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
                            arg3: c_ulong)
     -> c_ulong;
    pub fn __gmpz_tdiv_qr(arg1: mpz_ptr, arg2: mpz_ptr, arg3: mpz_srcptr,
                          arg4: mpz_srcptr);
    pub fn __gmpz_tdiv_qr_ui(arg1: mpz_ptr, arg2: mpz_ptr, arg3: mpz_srcptr,
                             arg4: c_ulong)
     -> c_ulong;
    pub fn __gmpz_tdiv_r(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
    pub fn __gmpz_tdiv_r_2exp(arg1: mpz_ptr, arg2: mpz_srcptr,
                              arg3: mp_bitcnt_t);
    pub fn __gmpz_tdiv_r_ui(arg1: mpz_ptr, arg2: mpz_srcptr,
                            arg3: c_ulong)
     -> c_ulong;
    pub fn __gmpz_tstbit(arg1: mpz_srcptr, arg2: mp_bitcnt_t)
     -> c_int;
    pub fn __gmpz_ui_pow_ui(arg1: mpz_ptr, arg2: c_ulong,
                            arg3: c_ulong);
    pub fn __gmpz_urandomb(arg1: mpz_ptr, arg2: gmp_randstate_t,
                           arg3: mp_bitcnt_t);
    pub fn __gmpz_urandomm(arg1: mpz_ptr, arg2: gmp_randstate_t,
                           arg3: mpz_srcptr);
    pub fn __gmpz_xor(arg1: mpz_ptr, arg2: mpz_srcptr, arg3: mpz_srcptr);
    pub fn __gmpz_limbs_read(arg1: mpz_srcptr) -> mp_srcptr;
    pub fn __gmpz_limbs_write(arg1: mpz_ptr, arg2: mp_size_t) -> mp_ptr;
    pub fn __gmpz_limbs_modify(arg1: mpz_ptr, arg2: mp_size_t) -> mp_ptr;
    pub fn __gmpz_limbs_finish(arg1: mpz_ptr, arg2: mp_size_t);
    pub fn __gmpz_roinit_n(arg1: mpz_ptr, arg2: mp_srcptr, arg3: mp_size_t)
     -> mpz_srcptr;
    pub fn __gmpq_abs(__gmp_w: mpq_ptr, __gmp_u: mpq_srcptr);
    pub fn __gmpq_add(arg1: mpq_ptr, arg2: mpq_srcptr, arg3: mpq_srcptr);
    pub fn __gmpq_canonicalize(arg1: mpq_ptr);
    pub fn __gmpq_clear(arg1: mpq_ptr);
    pub fn __gmpq_clears(arg1: mpq_ptr, ...);
    pub fn __gmpq_cmp(arg1: mpq_srcptr, arg2: mpq_srcptr)
     -> c_int;
    pub fn __gmpq_cmp_si(arg1: mpq_srcptr, arg2: c_long,
                         arg3: c_ulong)
     -> c_int;
    pub fn __gmpq_cmp_ui(arg1: mpq_srcptr, arg2: c_ulong,
                         arg3: c_ulong)
     -> c_int;
    pub fn __gmpq_cmp_z(arg1: mpq_srcptr, arg2: mpz_srcptr)
     -> c_int;
    pub fn __gmpq_div(arg1: mpq_ptr, arg2: mpq_srcptr, arg3: mpq_srcptr);
    pub fn __gmpq_div_2exp(arg1: mpq_ptr, arg2: mpq_srcptr,
                           arg3: mp_bitcnt_t);
    pub fn __gmpq_equal(arg1: mpq_srcptr, arg2: mpq_srcptr)
     -> c_int;
    pub fn __gmpq_get_num(arg1: mpz_ptr, arg2: mpq_srcptr);
    pub fn __gmpq_get_den(arg1: mpz_ptr, arg2: mpq_srcptr);
    pub fn __gmpq_get_d(arg1: mpq_srcptr) -> c_double;
    pub fn __gmpq_get_str(arg1: *mut c_char,
                          arg2: c_int, arg3: mpq_srcptr)
     -> *mut c_char;
    pub fn __gmpq_init(arg1: mpq_ptr);
    pub fn __gmpq_inits(arg1: mpq_ptr, ...);
    pub fn __gmpq_inv(arg1: mpq_ptr, arg2: mpq_srcptr);
    pub fn __gmpq_mul(arg1: mpq_ptr, arg2: mpq_srcptr, arg3: mpq_srcptr);
    pub fn __gmpq_mul_2exp(arg1: mpq_ptr, arg2: mpq_srcptr,
                           arg3: mp_bitcnt_t);
    pub fn __gmpq_neg(__gmp_w: mpq_ptr, __gmp_u: mpq_srcptr);
    pub fn __gmpq_set(arg1: mpq_ptr, arg2: mpq_srcptr);
    pub fn __gmpq_set_d(arg1: mpq_ptr, arg2: c_double);
    pub fn __gmpq_set_den(arg1: mpq_ptr, arg2: mpz_srcptr);
    pub fn __gmpq_set_f(arg1: mpq_ptr, arg2: mpf_srcptr);
    pub fn __gmpq_set_num(arg1: mpq_ptr, arg2: mpz_srcptr);
    pub fn __gmpq_set_si(arg1: mpq_ptr, arg2: c_long,
                         arg3: c_ulong);
    pub fn __gmpq_set_str(arg1: mpq_ptr, arg2: *const c_char,
                          arg3: c_int)
     -> c_int;
    pub fn __gmpq_set_ui(arg1: mpq_ptr, arg2: c_ulong,
                         arg3: c_ulong);
    pub fn __gmpq_set_z(arg1: mpq_ptr, arg2: mpz_srcptr);
    pub fn __gmpq_sub(arg1: mpq_ptr, arg2: mpq_srcptr, arg3: mpq_srcptr);
    pub fn __gmpq_swap(arg1: mpq_ptr, arg2: mpq_ptr);
    pub fn __gmpf_abs(arg1: mpf_ptr, arg2: mpf_srcptr);
    pub fn __gmpf_add(arg1: mpf_ptr, arg2: mpf_srcptr, arg3: mpf_srcptr);
    pub fn __gmpf_add_ui(arg1: mpf_ptr, arg2: mpf_srcptr,
                         arg3: c_ulong);
    pub fn __gmpf_ceil(arg1: mpf_ptr, arg2: mpf_srcptr);
    pub fn __gmpf_clear(arg1: mpf_ptr);
    pub fn __gmpf_clears(arg1: mpf_ptr, ...);
    pub fn __gmpf_cmp(arg1: mpf_srcptr, arg2: mpf_srcptr)
     -> c_int;
    pub fn __gmpf_cmp_z(arg1: mpf_srcptr, arg2: mpz_srcptr)
     -> c_int;
    pub fn __gmpf_cmp_d(arg1: mpf_srcptr, arg2: c_double)
     -> c_int;
    pub fn __gmpf_cmp_si(arg1: mpf_srcptr, arg2: c_long)
     -> c_int;
    pub fn __gmpf_cmp_ui(arg1: mpf_srcptr, arg2: c_ulong)
     -> c_int;
    pub fn __gmpf_div(arg1: mpf_ptr, arg2: mpf_srcptr, arg3: mpf_srcptr);
    pub fn __gmpf_div_2exp(arg1: mpf_ptr, arg2: mpf_srcptr,
                           arg3: mp_bitcnt_t);
    pub fn __gmpf_div_ui(arg1: mpf_ptr, arg2: mpf_srcptr,
                         arg3: c_ulong);
    pub fn __gmpf_dump(arg1: mpf_srcptr);
    pub fn __gmpf_eq(arg1: mpf_srcptr, arg2: mpf_srcptr, arg3: mp_bitcnt_t)
     -> c_int;
    pub fn __gmpf_fits_sint_p(arg1: mpf_srcptr) -> c_int;
    pub fn __gmpf_fits_slong_p(arg1: mpf_srcptr) -> c_int;
    pub fn __gmpf_fits_sshort_p(arg1: mpf_srcptr) -> c_int;
    pub fn __gmpf_fits_uint_p(arg1: mpf_srcptr) -> c_int;
    pub fn __gmpf_fits_ulong_p(arg1: mpf_srcptr) -> c_int;
    pub fn __gmpf_fits_ushort_p(arg1: mpf_srcptr) -> c_int;
    pub fn __gmpf_floor(arg1: mpf_ptr, arg2: mpf_srcptr);
    pub fn __gmpf_get_d(arg1: mpf_srcptr) -> c_double;
    pub fn __gmpf_get_d_2exp(arg1: *mut c_long,
                             arg2: mpf_srcptr) -> c_double;
    pub fn __gmpf_get_default_prec() -> mp_bitcnt_t;
    pub fn __gmpf_get_prec(arg1: mpf_srcptr) -> mp_bitcnt_t;
    pub fn __gmpf_get_si(arg1: mpf_srcptr) -> c_long;
    pub fn __gmpf_get_str(arg1: *mut c_char,
                          arg2: *mut mp_exp_t, arg3: c_int,
                          arg4: size_t, arg5: mpf_srcptr)
     -> *mut c_char;
    pub fn __gmpf_get_ui(arg1: mpf_srcptr) -> c_ulong;
    pub fn __gmpf_init(arg1: mpf_ptr);
    pub fn __gmpf_init2(arg1: mpf_ptr, arg2: mp_bitcnt_t);
    pub fn __gmpf_inits(arg1: mpf_ptr, ...);
    pub fn __gmpf_init_set(arg1: mpf_ptr, arg2: mpf_srcptr);
    pub fn __gmpf_init_set_d(arg1: mpf_ptr, arg2: c_double);
    pub fn __gmpf_init_set_si(arg1: mpf_ptr, arg2: c_long);
    pub fn __gmpf_init_set_str(arg1: mpf_ptr,
                               arg2: *const c_char,
                               arg3: c_int)
     -> c_int;
    pub fn __gmpf_init_set_ui(arg1: mpf_ptr, arg2: c_ulong);
    pub fn __gmpf_integer_p(arg1: mpf_srcptr) -> c_int;
    pub fn __gmpf_mul(arg1: mpf_ptr, arg2: mpf_srcptr, arg3: mpf_srcptr);
    pub fn __gmpf_mul_2exp(arg1: mpf_ptr, arg2: mpf_srcptr,
                           arg3: mp_bitcnt_t);
    pub fn __gmpf_mul_ui(arg1: mpf_ptr, arg2: mpf_srcptr,
                         arg3: c_ulong);
    pub fn __gmpf_neg(arg1: mpf_ptr, arg2: mpf_srcptr);
    pub fn __gmpf_pow_ui(arg1: mpf_ptr, arg2: mpf_srcptr,
                         arg3: c_ulong);
    pub fn __gmpf_random2(arg1: mpf_ptr, arg2: mp_size_t, arg3: mp_exp_t);
    pub fn __gmpf_reldiff(arg1: mpf_ptr, arg2: mpf_srcptr, arg3: mpf_srcptr);
    pub fn __gmpf_set(arg1: mpf_ptr, arg2: mpf_srcptr);
    pub fn __gmpf_set_d(arg1: mpf_ptr, arg2: c_double);
    pub fn __gmpf_set_default_prec(arg1: mp_bitcnt_t);
    pub fn __gmpf_set_prec(arg1: mpf_ptr, arg2: mp_bitcnt_t);
    pub fn __gmpf_set_prec_raw(arg1: mpf_ptr, arg2: mp_bitcnt_t);
    pub fn __gmpf_set_q(arg1: mpf_ptr, arg2: mpq_srcptr);
    pub fn __gmpf_set_si(arg1: mpf_ptr, arg2: c_long);
    pub fn __gmpf_set_str(arg1: mpf_ptr, arg2: *const c_char,
                          arg3: c_int)
     -> c_int;
    pub fn __gmpf_set_ui(arg1: mpf_ptr, arg2: c_ulong);
    pub fn __gmpf_set_z(arg1: mpf_ptr, arg2: mpz_srcptr);
    pub fn __gmpf_size(arg1: mpf_srcptr) -> size_t;
    pub fn __gmpf_sqrt(arg1: mpf_ptr, arg2: mpf_srcptr);
    pub fn __gmpf_sqrt_ui(arg1: mpf_ptr, arg2: c_ulong);
    pub fn __gmpf_sub(arg1: mpf_ptr, arg2: mpf_srcptr, arg3: mpf_srcptr);
    pub fn __gmpf_sub_ui(arg1: mpf_ptr, arg2: mpf_srcptr,
                         arg3: c_ulong);
    pub fn __gmpf_swap(arg1: mpf_ptr, arg2: mpf_ptr);
    pub fn __gmpf_trunc(arg1: mpf_ptr, arg2: mpf_srcptr);
    pub fn __gmpf_ui_div(arg1: mpf_ptr, arg2: c_ulong,
                         arg3: mpf_srcptr);
    pub fn __gmpf_ui_sub(arg1: mpf_ptr, arg2: c_ulong,
                         arg3: mpf_srcptr);
    pub fn __gmpf_urandomb(arg1: mpf_t, arg2: gmp_randstate_t,
                           arg3: mp_bitcnt_t);
    pub fn __gmpn_add(__gmp_wp: mp_ptr, __gmp_xp: mp_srcptr,
                      __gmp_xsize: mp_size_t, __gmp_yp: mp_srcptr,
                      __gmp_ysize: mp_size_t) -> mp_limb_t;
    pub fn __gmpn_add_1(__gmp_dst: mp_ptr, __gmp_src: mp_srcptr,
                        __gmp_size: mp_size_t, __gmp_n: mp_limb_t)
     -> mp_limb_t;
    pub fn __gmpn_add_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
                        arg4: mp_size_t) -> mp_limb_t;
    pub fn __gmpn_addmul_1(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
                           arg4: mp_limb_t) -> mp_limb_t;
    pub fn __gmpn_cmp(__gmp_xp: mp_srcptr, __gmp_yp: mp_srcptr,
                      __gmp_size: mp_size_t) -> c_int;
    pub fn __gmpn_zero_p(__gmp_p: mp_srcptr, __gmp_n: mp_size_t)
     -> c_int;
    pub fn __gmpn_divexact_1(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
                             arg4: mp_limb_t);
    pub fn __gmpn_divexact_by3c(arg1: mp_ptr, arg2: mp_srcptr,
                                arg3: mp_size_t, arg4: mp_limb_t)
     -> mp_limb_t;
    pub fn __gmpn_divrem(arg1: mp_ptr, arg2: mp_size_t, arg3: mp_ptr,
                         arg4: mp_size_t, arg5: mp_srcptr, arg6: mp_size_t)
     -> mp_limb_t;
    pub fn __gmpn_divrem_1(arg1: mp_ptr, arg2: mp_size_t, arg3: mp_srcptr,
                           arg4: mp_size_t, arg5: mp_limb_t) -> mp_limb_t;
    pub fn __gmpn_divrem_2(arg1: mp_ptr, arg2: mp_size_t, arg3: mp_ptr,
                           arg4: mp_size_t, arg5: mp_srcptr) -> mp_limb_t;
    pub fn __gmpn_div_qr_1(arg1: mp_ptr, arg2: *mut mp_limb_t,
                           arg3: mp_srcptr, arg4: mp_size_t, arg5: mp_limb_t)
     -> mp_limb_t;
    pub fn __gmpn_div_qr_2(arg1: mp_ptr, arg2: mp_ptr, arg3: mp_srcptr,
                           arg4: mp_size_t, arg5: mp_srcptr) -> mp_limb_t;
    pub fn __gmpn_gcd(arg1: mp_ptr, arg2: mp_ptr, arg3: mp_size_t,
                      arg4: mp_ptr, arg5: mp_size_t) -> mp_size_t;
    pub fn __gmpn_gcd_1(arg1: mp_srcptr, arg2: mp_size_t, arg3: mp_limb_t)
     -> mp_limb_t;
    pub fn __gmpn_gcdext_1(arg1: *mut mp_limb_signed_t,
                           arg2: *mut mp_limb_signed_t, arg3: mp_limb_t,
                           arg4: mp_limb_t) -> mp_limb_t;
    pub fn __gmpn_gcdext(arg1: mp_ptr, arg2: mp_ptr, arg3: *mut mp_size_t,
                         arg4: mp_ptr, arg5: mp_size_t, arg6: mp_ptr,
                         arg7: mp_size_t) -> mp_size_t;
    pub fn __gmpn_get_str(arg1: *mut c_uchar,
                          arg2: c_int, arg3: mp_ptr,
                          arg4: mp_size_t) -> size_t;
    pub fn __gmpn_hamdist(arg1: mp_srcptr, arg2: mp_srcptr, arg3: mp_size_t)
     -> mp_bitcnt_t;
    pub fn __gmpn_lshift(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
                         arg4: c_uint) -> mp_limb_t;
    pub fn __gmpn_mod_1(arg1: mp_srcptr, arg2: mp_size_t, arg3: mp_limb_t)
     -> mp_limb_t;
    pub fn __gmpn_mul(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
                      arg4: mp_srcptr, arg5: mp_size_t) -> mp_limb_t;
    pub fn __gmpn_mul_1(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
                        arg4: mp_limb_t) -> mp_limb_t;
    pub fn __gmpn_mul_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
                        arg4: mp_size_t);
    pub fn __gmpn_sqr(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t);
    pub fn __gmpn_neg(__gmp_rp: mp_ptr, __gmp_up: mp_srcptr,
                      __gmp_n: mp_size_t) -> mp_limb_t;
    pub fn __gmpn_com(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t);
    pub fn __gmpn_perfect_square_p(arg1: mp_srcptr, arg2: mp_size_t)
     -> c_int;
    pub fn __gmpn_perfect_power_p(arg1: mp_srcptr, arg2: mp_size_t)
     -> c_int;
    pub fn __gmpn_popcount(arg1: mp_srcptr, arg2: mp_size_t) -> mp_bitcnt_t;
    pub fn __gmpn_pow_1(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
                        arg4: mp_limb_t, arg5: mp_ptr) -> mp_size_t;
    pub fn __gmpn_preinv_mod_1(arg1: mp_srcptr, arg2: mp_size_t,
                               arg3: mp_limb_t, arg4: mp_limb_t) -> mp_limb_t;
    pub fn __gmpn_random(arg1: mp_ptr, arg2: mp_size_t);
    pub fn __gmpn_random2(arg1: mp_ptr, arg2: mp_size_t);
    pub fn __gmpn_rshift(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
                         arg4: c_uint) -> mp_limb_t;
    pub fn __gmpn_scan0(arg1: mp_srcptr, arg2: mp_bitcnt_t) -> mp_bitcnt_t;
    pub fn __gmpn_scan1(arg1: mp_srcptr, arg2: mp_bitcnt_t) -> mp_bitcnt_t;
    pub fn __gmpn_set_str(arg1: mp_ptr, arg2: *const c_uchar,
                          arg3: size_t, arg4: c_int)
     -> mp_size_t;
    pub fn __gmpn_sizeinbase(arg1: mp_srcptr, arg2: mp_size_t,
                             arg3: c_int) -> size_t;
    pub fn __gmpn_sqrtrem(arg1: mp_ptr, arg2: mp_ptr, arg3: mp_srcptr,
                          arg4: mp_size_t) -> mp_size_t;
    pub fn __gmpn_sub(__gmp_wp: mp_ptr, __gmp_xp: mp_srcptr,
                      __gmp_xsize: mp_size_t, __gmp_yp: mp_srcptr,
                      __gmp_ysize: mp_size_t) -> mp_limb_t;
    pub fn __gmpn_sub_1(__gmp_dst: mp_ptr, __gmp_src: mp_srcptr,
                        __gmp_size: mp_size_t, __gmp_n: mp_limb_t)
     -> mp_limb_t;
    pub fn __gmpn_sub_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
                        arg4: mp_size_t) -> mp_limb_t;
    pub fn __gmpn_submul_1(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
                           arg4: mp_limb_t) -> mp_limb_t;
    pub fn __gmpn_tdiv_qr(arg1: mp_ptr, arg2: mp_ptr, arg3: mp_size_t,
                          arg4: mp_srcptr, arg5: mp_size_t, arg6: mp_srcptr,
                          arg7: mp_size_t);
    pub fn __gmpn_and_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
                        arg4: mp_size_t);
    pub fn __gmpn_andn_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
                         arg4: mp_size_t);
    pub fn __gmpn_nand_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
                         arg4: mp_size_t);
    pub fn __gmpn_ior_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
                        arg4: mp_size_t);
    pub fn __gmpn_iorn_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
                         arg4: mp_size_t);
    pub fn __gmpn_nior_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
                         arg4: mp_size_t);
    pub fn __gmpn_xor_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
                        arg4: mp_size_t);
    pub fn __gmpn_xnor_n(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_srcptr,
                         arg4: mp_size_t);
    pub fn __gmpn_copyi(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t);
    pub fn __gmpn_copyd(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t);
    pub fn __gmpn_zero(arg1: mp_ptr, arg2: mp_size_t);
    pub fn __gmpn_cnd_add_n(arg1: mp_limb_t, arg2: mp_ptr, arg3: mp_srcptr,
                            arg4: mp_srcptr, arg5: mp_size_t) -> mp_limb_t;
    pub fn __gmpn_cnd_sub_n(arg1: mp_limb_t, arg2: mp_ptr, arg3: mp_srcptr,
                            arg4: mp_srcptr, arg5: mp_size_t) -> mp_limb_t;
    pub fn __gmpn_sec_add_1(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
                            arg4: mp_limb_t, arg5: mp_ptr) -> mp_limb_t;
    pub fn __gmpn_sec_add_1_itch(arg1: mp_size_t) -> mp_size_t;
    pub fn __gmpn_sec_sub_1(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
                            arg4: mp_limb_t, arg5: mp_ptr) -> mp_limb_t;
    pub fn __gmpn_sec_sub_1_itch(arg1: mp_size_t) -> mp_size_t;
    pub fn __gmpn_cnd_swap(arg1: mp_limb_t, arg2: *mut mp_limb_t,
                           arg3: *mut mp_limb_t, arg4: mp_size_t);
    pub fn __gmpn_sec_mul(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
                          arg4: mp_srcptr, arg5: mp_size_t, arg6: mp_ptr);
    pub fn __gmpn_sec_mul_itch(arg1: mp_size_t, arg2: mp_size_t) -> mp_size_t;
    pub fn __gmpn_sec_sqr(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
                          arg4: mp_ptr);
    pub fn __gmpn_sec_sqr_itch(arg1: mp_size_t) -> mp_size_t;
    pub fn __gmpn_sec_powm(arg1: mp_ptr, arg2: mp_srcptr, arg3: mp_size_t,
                           arg4: mp_srcptr, arg5: mp_bitcnt_t,
                           arg6: mp_srcptr, arg7: mp_size_t, arg8: mp_ptr);
    pub fn __gmpn_sec_powm_itch(arg1: mp_size_t, arg2: mp_bitcnt_t,
                                arg3: mp_size_t) -> mp_size_t;
    pub fn __gmpn_sec_tabselect(arg1: *mut mp_limb_t, arg2: *const mp_limb_t,
                                arg3: mp_size_t, arg4: mp_size_t,
                                arg5: mp_size_t);
    pub fn __gmpn_sec_div_qr(arg1: mp_ptr, arg2: mp_ptr, arg3: mp_size_t,
                             arg4: mp_srcptr, arg5: mp_size_t, arg6: mp_ptr)
     -> mp_limb_t;
    pub fn __gmpn_sec_div_qr_itch(arg1: mp_size_t, arg2: mp_size_t)
     -> mp_size_t;
    pub fn __gmpn_sec_div_r(arg1: mp_ptr, arg2: mp_size_t, arg3: mp_srcptr,
                            arg4: mp_size_t, arg5: mp_ptr);
    pub fn __gmpn_sec_div_r_itch(arg1: mp_size_t, arg2: mp_size_t)
     -> mp_size_t;
    pub fn __gmpn_sec_invert(arg1: mp_ptr, arg2: mp_ptr, arg3: mp_srcptr,
                             arg4: mp_size_t, arg5: mp_bitcnt_t, arg6: mp_ptr)
     -> c_int;
    pub fn __gmpn_sec_invert_itch(arg1: mp_size_t) -> mp_size_t;
    pub fn select(__nfds: c_int, __readfds: *mut fd_set,
                  __writefds: *mut fd_set, __exceptfds: *mut fd_set,
                  __timeout: *mut Struct_timeval) -> c_int;
    pub fn pselect(__nfds: c_int, __readfds: *mut fd_set,
                   __writefds: *mut fd_set, __exceptfds: *mut fd_set,
                   __timeout: *const Struct_timespec,
                   __sigmask: *const __sigset_t) -> c_int;
    pub fn gettimeofday(__tv: *mut Struct_timeval, __tz: __timezone_ptr_t)
     -> c_int;
    pub fn settimeofday(__tv: *const Struct_timeval,
                        __tz: *const Struct_timezone)
     -> c_int;
    pub fn adjtime(__delta: *const Struct_timeval,
                   __olddelta: *mut Struct_timeval) -> c_int;
    pub fn getitimer(__which: __itimer_which_t,
                     __value: *mut Struct_itimerval) -> c_int;
    pub fn setitimer(__which: __itimer_which_t,
                     __new: *const Struct_itimerval,
                     __old: *mut Struct_itimerval) -> c_int;
    pub fn utimes(__file: *const c_char,
                  __tvp: *mut Struct_timeval) -> c_int;
    pub fn lutimes(__file: *const c_char,
                   __tvp: *mut Struct_timeval) -> c_int;
    pub fn futimes(__fd: c_int, __tvp: *mut Struct_timeval)
     -> c_int;
    pub fn clock() -> clock_t;
    pub fn time(__timer: *mut time_t) -> time_t;
    pub fn difftime(__time1: time_t, __time0: time_t)
     -> c_double;
    pub fn mktime(__tp: *mut Struct_tm) -> time_t;
    pub fn strftime(__s: *mut c_char, __maxsize: size_t,
                    __format: *const c_char,
                    __tp: *const Struct_tm) -> size_t;
    pub fn strftime_l(__s: *mut c_char, __maxsize: size_t,
                      __format: *const 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 c_char;
    pub fn ctime(__timer: *const time_t) -> *mut c_char;
    pub fn asctime_r(__tp: *const Struct_tm,
                     __buf: *mut c_char)
     -> *mut c_char;
    pub fn ctime_r(__timer: *const time_t, __buf: *mut c_char)
     -> *mut c_char;
    pub fn tzset();
    pub fn stime(__when: *const time_t) -> c_int;
    pub fn timegm(__tp: *mut Struct_tm) -> time_t;
    pub fn timelocal(__tp: *mut Struct_tm) -> time_t;
    pub fn dysize(__year: c_int) -> c_int;
    pub fn nanosleep(__requested_time: *const Struct_timespec,
                     __remaining: *mut Struct_timespec)
     -> c_int;
    pub fn clock_getres(__clock_id: clockid_t, __res: *mut Struct_timespec)
     -> c_int;
    pub fn clock_gettime(__clock_id: clockid_t, __tp: *mut Struct_timespec)
     -> c_int;
    pub fn clock_settime(__clock_id: clockid_t, __tp: *const Struct_timespec)
     -> c_int;
    pub fn clock_nanosleep(__clock_id: clockid_t,
                           __flags: c_int,
                           __req: *const Struct_timespec,
                           __rem: *mut Struct_timespec)
     -> c_int;
    pub fn clock_getcpuclockid(__pid: pid_t, __clock_id: *mut clockid_t)
     -> c_int;
    pub fn timer_create(__clock_id: clockid_t, __evp: *mut Struct_sigevent,
                        __timerid: *mut timer_t) -> c_int;
    pub fn timer_delete(__timerid: timer_t) -> c_int;
    pub fn timer_settime(__timerid: timer_t, __flags: c_int,
                         __value: *const Struct_itimerspec,
                         __ovalue: *mut Struct_itimerspec)
     -> c_int;
    pub fn timer_gettime(__timerid: timer_t, __value: *mut Struct_itimerspec)
     -> c_int;
    pub fn timer_getoverrun(__timerid: timer_t) -> c_int;
    pub fn timespec_get(__ts: *mut Struct_timespec,
                        __base: c_int)
     -> c_int;
    pub fn __ctype_get_mb_cur_max() -> size_t;
    pub fn atof(__nptr: *const c_char)
     -> c_double;
    pub fn atoi(__nptr: *const c_char)
     -> c_int;
    pub fn atol(__nptr: *const c_char)
     -> c_long;
    pub fn atoll(__nptr: *const c_char)
     -> c_longlong;
    pub fn strtod(__nptr: *const c_char,
                  __endptr: *mut *mut c_char)
     -> c_double;
    pub fn strtof(__nptr: *const c_char,
                  __endptr: *mut *mut c_char)
     -> c_float;
    pub fn strtold(__nptr: *const c_char,
                   __endptr: *mut *mut c_char)
     -> c_double;
    pub fn strtol(__nptr: *const c_char,
                  __endptr: *mut *mut c_char,
                  __base: c_int) -> c_long;
    pub fn strtoul(__nptr: *const c_char,
                   __endptr: *mut *mut c_char,
                   __base: c_int) -> c_ulong;
    pub fn strtoq(__nptr: *const c_char,
                  __endptr: *mut *mut c_char,
                  __base: c_int)
     -> c_longlong;
    pub fn strtouq(__nptr: *const c_char,
                   __endptr: *mut *mut c_char,
                   __base: c_int)
     -> c_ulonglong;
    pub fn strtoll(__nptr: *const c_char,
                   __endptr: *mut *mut c_char,
                   __base: c_int)
     -> c_longlong;
    pub fn strtoull(__nptr: *const c_char,
                    __endptr: *mut *mut c_char,
                    __base: c_int)
     -> c_ulonglong;
    pub fn l64a(__n: c_long) -> *mut c_char;
    pub fn a64l(__s: *const c_char) -> c_long;
    pub fn gnu_dev_major(__dev: c_ulonglong)
     -> c_uint;
    pub fn gnu_dev_minor(__dev: c_ulonglong)
     -> c_uint;
    pub fn gnu_dev_makedev(__major: c_uint,
                           __minor: c_uint)
     -> c_ulonglong;
    pub fn random() -> c_long;
    pub fn srandom(__seed: c_uint);
    pub fn initstate(__seed: c_uint,
                     __statebuf: *mut c_char,
                     __statelen: size_t) -> *mut c_char;
    pub fn setstate(__statebuf: *mut c_char)
     -> *mut c_char;
    pub fn random_r(__buf: *mut Struct_random_data, __result: *mut int32_t)
     -> c_int;
    pub fn srandom_r(__seed: c_uint,
                     __buf: *mut Struct_random_data) -> c_int;
    pub fn initstate_r(__seed: c_uint,
                       __statebuf: *mut c_char,
                       __statelen: size_t, __buf: *mut Struct_random_data)
     -> c_int;
    pub fn setstate_r(__statebuf: *mut c_char,
                      __buf: *mut Struct_random_data)
     -> c_int;
    pub fn rand() -> c_int;
    pub fn srand(__seed: c_uint);
    pub fn rand_r(__seed: *mut c_uint)
     -> c_int;
    pub fn drand48() -> c_double;
    pub fn erand48(__xsubi: *mut c_ushort)
     -> c_double;
    pub fn lrand48() -> c_long;
    pub fn nrand48(__xsubi: *mut c_ushort)
     -> c_long;
    pub fn mrand48() -> c_long;
    pub fn jrand48(__xsubi: *mut c_ushort)
     -> c_long;
    pub fn srand48(__seedval: c_long);
    pub fn seed48(__seed16v: *mut c_ushort)
     -> *mut c_ushort;
    pub fn lcong48(__param: *mut c_ushort);
    pub fn drand48_r(__buffer: *mut Struct_drand48_data,
                     __result: *mut c_double)
     -> c_int;
    pub fn erand48_r(__xsubi: *mut c_ushort,
                     __buffer: *mut Struct_drand48_data,
                     __result: *mut c_double)
     -> c_int;
    pub fn lrand48_r(__buffer: *mut Struct_drand48_data,
                     __result: *mut c_long)
     -> c_int;
    pub fn nrand48_r(__xsubi: *mut c_ushort,
                     __buffer: *mut Struct_drand48_data,
                     __result: *mut c_long)
     -> c_int;
    pub fn mrand48_r(__buffer: *mut Struct_drand48_data,
                     __result: *mut c_long)
     -> c_int;
    pub fn jrand48_r(__xsubi: *mut c_ushort,
                     __buffer: *mut Struct_drand48_data,
                     __result: *mut c_long)
     -> c_int;
    pub fn srand48_r(__seedval: c_long,
                     __buffer: *mut Struct_drand48_data)
     -> c_int;
    pub fn seed48_r(__seed16v: *mut c_ushort,
                    __buffer: *mut Struct_drand48_data)
     -> c_int;
    pub fn lcong48_r(__param: *mut c_ushort,
                     __buffer: *mut Struct_drand48_data)
     -> c_int;
    pub fn malloc(__size: size_t) -> *mut c_void;
    pub fn calloc(__nmemb: size_t, __size: size_t)
     -> *mut c_void;
    pub fn realloc(__ptr: *mut c_void, __size: size_t)
     -> *mut c_void;
    pub fn free(__ptr: *mut c_void);
    pub fn cfree(__ptr: *mut c_void);
    pub fn alloca(__size: size_t) -> *mut c_void;
    pub fn valloc(__size: size_t) -> *mut c_void;
    pub fn posix_memalign(__memptr: *mut *mut c_void,
                          __alignment: size_t, __size: size_t)
     -> c_int;
    pub fn aligned_alloc(__alignment: size_t, __size: size_t)
     -> *mut c_void;
    pub fn abort();
    pub fn atexit(__func: ::std::option::Option<extern "C" fn()>)
     -> c_int;
    pub fn at_quick_exit(__func: ::std::option::Option<extern "C" fn()>)
     -> c_int;
    pub fn on_exit(__func:
                       ::std::option::Option<unsafe extern "C" fn(__status:
                                                                      c_int,
                                                                  __arg:
                                                                      *mut c_void)>,
                   __arg: *mut c_void)
     -> c_int;
    pub fn exit(__status: c_int);
    pub fn quick_exit(__status: c_int);
    pub fn _Exit(__status: c_int);
    pub fn getenv(__name: *const c_char)
     -> *mut c_char;
    pub fn putenv(__string: *mut c_char)
     -> c_int;
    pub fn setenv(__name: *const c_char,
                  __value: *const c_char,
                  __replace: c_int) -> c_int;
    pub fn unsetenv(__name: *const c_char)
     -> c_int;
    pub fn clearenv() -> c_int;
    pub fn mktemp(__template: *mut c_char)
     -> *mut c_char;
    pub fn mkstemp(__template: *mut c_char)
     -> c_int;
    pub fn mkstemps(__template: *mut c_char,
                    __suffixlen: c_int)
     -> c_int;
    pub fn mkdtemp(__template: *mut c_char)
     -> *mut c_char;
    pub fn system(__command: *const c_char)
     -> c_int;
    pub fn realpath(__name: *const c_char,
                    __resolved: *mut c_char)
     -> *mut c_char;
    pub fn bsearch(__key: *const c_void,
                   __base: *const c_void, __nmemb: size_t,
                   __size: size_t, __compar: __compar_fn_t)
     -> *mut c_void;
    pub fn qsort(__base: *mut c_void, __nmemb: size_t,
                 __size: size_t, __compar: __compar_fn_t);
    pub fn abs(__x: c_int) -> c_int;
    pub fn labs(__x: c_long) -> c_long;
    pub fn llabs(__x: c_longlong)
     -> c_longlong;
    pub fn div(__numer: c_int, __denom: c_int)
     -> div_t;
    pub fn ldiv(__numer: c_long,
                __denom: c_long) -> ldiv_t;
    pub fn lldiv(__numer: c_longlong,
                 __denom: c_longlong) -> lldiv_t;
    pub fn ecvt(__value: c_double,
                __ndigit: c_int,
                __decpt: *mut c_int,
                __sign: *mut c_int)
     -> *mut c_char;
    pub fn fcvt(__value: c_double,
                __ndigit: c_int,
                __decpt: *mut c_int,
                __sign: *mut c_int)
     -> *mut c_char;
    pub fn gcvt(__value: c_double,
                __ndigit: c_int,
                __buf: *mut c_char)
     -> *mut c_char;
    pub fn qecvt(__value: c_double,
                 __ndigit: c_int,
                 __decpt: *mut c_int,
                 __sign: *mut c_int)
     -> *mut c_char;
    pub fn qfcvt(__value: c_double,
                 __ndigit: c_int,
                 __decpt: *mut c_int,
                 __sign: *mut c_int)
     -> *mut c_char;
    pub fn qgcvt(__value: c_double,
                 __ndigit: c_int,
                 __buf: *mut c_char)
     -> *mut c_char;
    pub fn ecvt_r(__value: c_double,
                  __ndigit: c_int,
                  __decpt: *mut c_int,
                  __sign: *mut c_int,
                  __buf: *mut c_char, __len: size_t)
     -> c_int;
    pub fn fcvt_r(__value: c_double,
                  __ndigit: c_int,
                  __decpt: *mut c_int,
                  __sign: *mut c_int,
                  __buf: *mut c_char, __len: size_t)
     -> c_int;
    pub fn qecvt_r(__value: c_double,
                   __ndigit: c_int,
                   __decpt: *mut c_int,
                   __sign: *mut c_int,
                   __buf: *mut c_char, __len: size_t)
     -> c_int;
    pub fn qfcvt_r(__value: c_double,
                   __ndigit: c_int,
                   __decpt: *mut c_int,
                   __sign: *mut c_int,
                   __buf: *mut c_char, __len: size_t)
     -> c_int;
    pub fn mblen(__s: *const c_char, __n: size_t)
     -> c_int;
    pub fn mbtowc(__pwc: *mut wchar_t, __s: *const c_char,
                  __n: size_t) -> c_int;
    pub fn wctomb(__s: *mut c_char, __wchar: wchar_t)
     -> c_int;
    pub fn mbstowcs(__pwcs: *mut wchar_t, __s: *const c_char,
                    __n: size_t) -> size_t;
    pub fn wcstombs(__s: *mut c_char, __pwcs: *const wchar_t,
                    __n: size_t) -> size_t;
    pub fn rpmatch(__response: *const c_char)
     -> c_int;
    pub fn getsubopt(__optionp: *mut *mut c_char,
                     __tokens: *const *mut c_char,
                     __valuep: *mut *mut c_char)
     -> c_int;
    pub fn getloadavg(__loadavg: *mut c_double,
                      __nelem: c_int)
     -> c_int;
    pub fn setjmp(__env: jmp_buf) -> c_int;
    pub fn __sigsetjmp(__env: *mut Struct___jmp_buf_tag,
                       __savemask: c_int)
     -> c_int;
    pub fn _setjmp(__env: *mut Struct___jmp_buf_tag) -> c_int;
    pub fn longjmp(__env: *mut Struct___jmp_buf_tag,
                   __val: c_int);
    pub fn _longjmp(__env: *mut Struct___jmp_buf_tag,
                    __val: c_int);
    pub fn siglongjmp(__env: sigjmp_buf, __val: c_int);
    pub fn scm_async_tick();
    pub fn scm_call_generic_0(gf: SCM) -> SCM;
    pub fn scm_call_generic_1(gf: SCM, a1: SCM) -> SCM;
    pub fn scm_call_generic_2(gf: SCM, a1: SCM, a2: SCM) -> SCM;
    pub fn scm_apply_generic(gf: SCM, args: SCM) -> SCM;
    pub fn scm_acons(w: SCM, x: SCM, y: SCM) -> SCM;
    pub fn scm_sloppy_assq(x: SCM, alist: SCM) -> SCM;
    pub fn scm_sloppy_assv(x: SCM, alist: SCM) -> SCM;
    pub fn scm_sloppy_assoc(x: SCM, alist: SCM) -> SCM;
    pub fn scm_assq(x: SCM, alist: SCM) -> SCM;
    pub fn scm_assv(x: SCM, alist: SCM) -> SCM;
    pub fn scm_assoc(x: SCM, alist: SCM) -> SCM;
    pub fn scm_assq_ref(alist: SCM, key: SCM) -> SCM;
    pub fn scm_assv_ref(alist: SCM, key: SCM) -> SCM;
    pub fn scm_assoc_ref(alist: SCM, key: SCM) -> SCM;
    pub fn scm_assq_set_x(alist: SCM, key: SCM, val: SCM) -> SCM;
    pub fn scm_assv_set_x(alist: SCM, key: SCM, val: SCM) -> SCM;
    pub fn scm_assoc_set_x(alist: SCM, key: SCM, val: SCM) -> SCM;
    pub fn scm_assq_remove_x(alist: SCM, key: SCM) -> SCM;
    pub fn scm_assv_remove_x(alist: SCM, key: SCM) -> SCM;
    pub fn scm_assoc_remove_x(alist: SCM, key: SCM) -> SCM;
    pub fn scm_init_alist();
    pub fn scm_make_arbiter(name: SCM) -> SCM;
    pub fn scm_try_arbiter(arb: SCM) -> SCM;
    pub fn scm_release_arbiter(arb: SCM) -> SCM;
    pub fn scm_init_arbiters();
    pub fn scm_error(key: SCM, subr: *const c_char,
                     message: *const c_char, args: SCM,
                     rest: SCM);
    pub fn scm_error_scm(key: SCM, subr: SCM, message: SCM, args: SCM,
                         rest: SCM) -> SCM;
    pub fn scm_strerror(err: SCM) -> SCM;
    pub fn scm_syserror(subr: *const c_char);
    pub fn scm_syserror_msg(subr: *const c_char,
                            message: *const c_char, args: SCM,
                            eno: c_int);
    pub fn scm_num_overflow(subr: *const c_char);
    pub fn scm_out_of_range(subr: *const c_char,
                            bad_value: SCM);
    pub fn scm_out_of_range_pos(subr: *const c_char,
                                bad_value: SCM, pos: SCM);
    pub fn scm_wrong_num_args(_proc: SCM);
    pub fn scm_error_num_args_subr(subr: *const c_char);
    pub fn scm_wrong_type_arg(subr: *const c_char,
                              pos: c_int, bad_value: SCM);
    pub fn scm_i_wrong_type_arg_symbol(symbol: SCM,
                                       pos: c_int,
                                       bad_value: SCM);
    pub fn scm_wrong_type_arg_msg(subr: *const c_char,
                                  pos: c_int, bad_value: SCM,
                                  sz: *const c_char);
    pub fn scm_memory_error(subr: *const c_char);
    pub fn scm_misc_error(subr: *const c_char,
                          message: *const c_char, args: SCM);
    pub fn scm_init_error();
    pub fn scm_char_p(x: SCM) -> SCM;
    pub fn scm_char_eq_p(x: SCM, y: SCM) -> SCM;
    pub fn scm_char_less_p(x: SCM, y: SCM) -> SCM;
    pub fn scm_char_leq_p(x: SCM, y: SCM) -> SCM;
    pub fn scm_char_gr_p(x: SCM, y: SCM) -> SCM;
    pub fn scm_char_geq_p(x: SCM, y: SCM) -> SCM;
    pub fn scm_char_ci_eq_p(x: SCM, y: SCM) -> SCM;
    pub fn scm_char_ci_less_p(x: SCM, y: SCM) -> SCM;
    pub fn scm_char_ci_leq_p(x: SCM, y: SCM) -> SCM;
    pub fn scm_char_ci_gr_p(x: SCM, y: SCM) -> SCM;
    pub fn scm_char_ci_geq_p(x: SCM, y: SCM) -> SCM;
    pub fn scm_char_alphabetic_p(chr: SCM) -> SCM;
    pub fn scm_char_numeric_p(chr: SCM) -> SCM;
    pub fn scm_char_whitespace_p(chr: SCM) -> SCM;
    pub fn scm_char_upper_case_p(chr: SCM) -> SCM;
    pub fn scm_char_lower_case_p(chr: SCM) -> SCM;
    pub fn scm_char_is_both_p(chr: SCM) -> SCM;
    pub fn scm_char_to_integer(chr: SCM) -> SCM;
    pub fn scm_integer_to_char(n: SCM) -> SCM;
    pub fn scm_char_upcase(chr: SCM) -> SCM;
    pub fn scm_char_downcase(chr: SCM) -> SCM;
    pub fn scm_char_titlecase(chr: SCM) -> SCM;
    pub fn scm_char_general_category(chr: SCM) -> SCM;
    pub fn scm_c_upcase(c: scm_t_wchar) -> scm_t_wchar;
    pub fn scm_c_downcase(c: scm_t_wchar) -> scm_t_wchar;
    pub fn scm_c_titlecase(c: scm_t_wchar) -> scm_t_wchar;
    pub fn scm_i_charname(chr: SCM) -> *const c_char;
    pub fn scm_i_charname_to_char(charname: *const c_char,
                                  charname_len: size_t) -> SCM;
    pub fn scm_init_chars();
    pub fn scm_options_try(args: SCM, options: *mut scm_t_option,
                           s: *const c_char,
                           dry_run: c_int) -> SCM;
    pub fn scm_options(arg1: SCM, arg2: *mut scm_t_option,
                       arg3: *const c_char) -> SCM;
    pub fn scm_init_opts(arg1:
                             ::std::option::Option<extern "C" fn(arg1: SCM)
                                                       -> SCM>,
                         arg2: *mut scm_t_option);
    pub fn scm_init_options();
    pub fn scm_print_options(setting: SCM) -> SCM;
    pub fn scm_make_print_state() -> SCM;
    pub fn scm_free_print_state(print_state: SCM);
    pub fn scm_i_port_with_print_state(port: SCM, print_state: SCM) -> SCM;
    pub fn scm_i_display_substring(str: SCM, start: size_t, end: size_t,
                                   port: SCM);
    pub fn scm_intprint(n: scm_t_intmax, radix: c_int,
                        port: SCM);
    pub fn scm_uintprint(n: scm_t_uintmax, radix: c_int,
                         port: SCM);
    pub fn scm_ipruk(hdr: *mut c_char, ptr: SCM, port: SCM);
    pub fn scm_iprlist(hdr: *mut c_char, exp: SCM,
                       tlr: c_int, port: SCM,
                       pstate: *mut scm_print_state);
    pub fn scm_i_print_symbol_name(sym: SCM, port: SCM);
    pub fn scm_print_symbol_name(str: *const c_char,
                                 len: size_t, port: SCM);
    pub fn scm_prin1(exp: SCM, port: SCM, writingp: c_int);
    pub fn scm_iprin1(exp: SCM, port: SCM, pstate: *mut scm_print_state);
    pub fn scm_write(obj: SCM, port: SCM) -> SCM;
    pub fn scm_display(obj: SCM, port: SCM) -> SCM;
    pub fn scm_simple_format(port: SCM, message: SCM, args: SCM) -> SCM;
    pub fn scm_newline(port: SCM) -> SCM;
    pub fn scm_write_char(chr: SCM, port: SCM) -> SCM;
    pub fn scm_printer_apply(_proc: SCM, exp: SCM, port: SCM,
                             arg1: *mut scm_print_state) -> SCM;
    pub fn scm_port_with_print_state(port: SCM, pstate: SCM) -> SCM;
    pub fn scm_get_print_state(port: SCM) -> SCM;
    pub fn scm_valid_oport_value_p(val: SCM) -> c_int;
    pub fn scm_init_print();
    pub fn scm_exact_p(x: SCM) -> SCM;
    pub fn scm_is_exact(x: SCM) -> c_int;
    pub fn scm_odd_p(n: SCM) -> SCM;
    pub fn scm_even_p(n: SCM) -> SCM;
    pub fn scm_finite_p(x: SCM) -> SCM;
    pub fn scm_inf_p(x: SCM) -> SCM;
    pub fn scm_nan_p(x: SCM) -> SCM;
    pub fn scm_inf() -> SCM;
    pub fn scm_nan() -> SCM;
    pub fn scm_abs(x: SCM) -> SCM;
    pub fn scm_quotient(x: SCM, y: SCM) -> SCM;
    pub fn scm_remainder(x: SCM, y: SCM) -> SCM;
    pub fn scm_modulo(x: SCM, y: SCM) -> SCM;
    pub fn scm_euclidean_divide(x: SCM, y: SCM, q: *mut SCM, r: *mut SCM);
    pub fn scm_euclidean_quotient(x: SCM, y: SCM) -> SCM;
    pub fn scm_euclidean_remainder(x: SCM, y: SCM) -> SCM;
    pub fn scm_floor_divide(x: SCM, y: SCM, q: *mut SCM, r: *mut SCM);
    pub fn scm_floor_quotient(x: SCM, y: SCM) -> SCM;
    pub fn scm_floor_remainder(x: SCM, y: SCM) -> SCM;
    pub fn scm_ceiling_divide(x: SCM, y: SCM, q: *mut SCM, r: *mut SCM);
    pub fn scm_ceiling_quotient(x: SCM, y: SCM) -> SCM;
    pub fn scm_ceiling_remainder(x: SCM, y: SCM) -> SCM;
    pub fn scm_truncate_divide(x: SCM, y: SCM, q: *mut SCM, r: *mut SCM);
    pub fn scm_truncate_quotient(x: SCM, y: SCM) -> SCM;
    pub fn scm_truncate_remainder(x: SCM, y: SCM) -> SCM;
    pub fn scm_centered_divide(x: SCM, y: SCM, q: *mut SCM, r: *mut SCM);
    pub fn scm_centered_quotient(x: SCM, y: SCM) -> SCM;
    pub fn scm_centered_remainder(x: SCM, y: SCM) -> SCM;
    pub fn scm_round_divide(x: SCM, y: SCM, q: *mut SCM, r: *mut SCM);
    pub fn scm_round_quotient(x: SCM, y: SCM) -> SCM;
    pub fn scm_round_remainder(x: SCM, y: SCM) -> SCM;
    pub fn scm_gcd(x: SCM, y: SCM) -> SCM;
    pub fn scm_lcm(n1: SCM, n2: SCM) -> SCM;
    pub fn scm_logand(n1: SCM, n2: SCM) -> SCM;
    pub fn scm_logior(n1: SCM, n2: SCM) -> SCM;
    pub fn scm_logxor(n1: SCM, n2: SCM) -> SCM;
    pub fn scm_logtest(n1: SCM, n2: SCM) -> SCM;
    pub fn scm_logbit_p(n1: SCM, n2: SCM) -> SCM;
    pub fn scm_lognot(n: SCM) -> SCM;
    pub fn scm_modulo_expt(n: SCM, k: SCM, m: SCM) -> SCM;
    pub fn scm_integer_expt(z1: SCM, z2: SCM) -> SCM;
    pub fn scm_ash(n: SCM, count: SCM) -> SCM;
    pub fn scm_round_ash(n: SCM, count: SCM) -> SCM;
    pub fn scm_bit_extract(n: SCM, start: SCM, end: SCM) -> SCM;
    pub fn scm_logcount(n: SCM) -> SCM;
    pub fn scm_integer_length(n: SCM) -> SCM;
    pub fn scm_i_euclidean_divide(x: SCM, y: SCM) -> SCM;
    pub fn scm_i_floor_divide(x: SCM, y: SCM) -> SCM;
    pub fn scm_i_ceiling_divide(x: SCM, y: SCM) -> SCM;
    pub fn scm_i_truncate_divide(x: SCM, y: SCM) -> SCM;
    pub fn scm_i_centered_divide(x: SCM, y: SCM) -> SCM;
    pub fn scm_i_round_divide(x: SCM, y: SCM) -> SCM;
    pub fn scm_i_gcd(x: SCM, y: SCM, rest: SCM) -> SCM;
    pub fn scm_i_lcm(x: SCM, y: SCM, rest: SCM) -> SCM;
    pub fn scm_i_logand(x: SCM, y: SCM, rest: SCM) -> SCM;
    pub fn scm_i_logior(x: SCM, y: SCM, rest: SCM) -> SCM;
    pub fn scm_i_logxor(x: SCM, y: SCM, rest: SCM) -> SCM;
    pub fn scm_iint2str(num: scm_t_intmax, rad: c_int,
                        p: *mut c_char) -> size_t;
    pub fn scm_iuint2str(num: scm_t_uintmax, rad: c_int,
                         p: *mut c_char) -> size_t;
    pub fn scm_number_to_string(x: SCM, radix: SCM) -> SCM;
    pub fn scm_print_real(sexp: SCM, port: SCM, pstate: *mut scm_print_state)
     -> c_int;
    pub fn scm_print_complex(sexp: SCM, port: SCM,
                             pstate: *mut scm_print_state)
     -> c_int;
    pub fn scm_bigprint(exp: SCM, port: SCM, pstate: *mut scm_print_state)
     -> c_int;
    pub fn scm_c_locale_stringn_to_number(mem: *const c_char,
                                          len: size_t,
                                          radix: c_uint)
     -> SCM;
    pub fn scm_i_string_to_number(str: SCM, radix: c_uint)
     -> SCM;
    pub fn scm_string_to_number(str: SCM, radix: SCM) -> SCM;
    pub fn scm_bigequal(x: SCM, y: SCM) -> SCM;
    pub fn scm_real_equalp(x: SCM, y: SCM) -> SCM;
    pub fn scm_complex_equalp(x: SCM, y: SCM) -> SCM;
    pub fn scm_number_p(x: SCM) -> SCM;
    pub fn scm_complex_p(x: SCM) -> SCM;
    pub fn scm_real_p(x: SCM) -> SCM;
    pub fn scm_rational_p(z: SCM) -> SCM;
    pub fn scm_integer_p(x: SCM) -> SCM;
    pub fn scm_exact_integer_p(x: SCM) -> SCM;
    pub fn scm_inexact_p(x: SCM) -> SCM;
    pub fn scm_is_inexact(x: SCM) -> c_int;
    pub fn scm_num_eq_p(x: SCM, y: SCM) -> SCM;
    pub fn scm_less_p(x: SCM, y: SCM) -> SCM;
    pub fn scm_gr_p(x: SCM, y: SCM) -> SCM;
    pub fn scm_leq_p(x: SCM, y: SCM) -> SCM;
    pub fn scm_geq_p(x: SCM, y: SCM) -> SCM;
    pub fn scm_zero_p(z: SCM) -> SCM;
    pub fn scm_positive_p(x: SCM) -> SCM;
    pub fn scm_negative_p(x: SCM) -> SCM;
    pub fn scm_max(x: SCM, y: SCM) -> SCM;
    pub fn scm_min(x: SCM, y: SCM) -> SCM;
    pub fn scm_sum(x: SCM, y: SCM) -> SCM;
    pub fn scm_oneplus(x: SCM) -> SCM;
    pub fn scm_difference(x: SCM, y: SCM) -> SCM;
    pub fn scm_oneminus(x: SCM) -> SCM;
    pub fn scm_product(x: SCM, y: SCM) -> SCM;
    pub fn scm_divide(x: SCM, y: SCM) -> SCM;
    pub fn scm_floor(x: SCM) -> SCM;
    pub fn scm_ceiling(x: SCM) -> SCM;
    pub fn scm_c_truncate(x: c_double)
     -> c_double;
    pub fn scm_c_round(x: c_double)
     -> c_double;
    pub fn scm_truncate_number(x: SCM) -> SCM;
    pub fn scm_round_number(x: SCM) -> SCM;
    pub fn scm_expt(z1: SCM, z2: SCM) -> SCM;
    pub fn scm_sin(z: SCM) -> SCM;
    pub fn scm_cos(z: SCM) -> SCM;
    pub fn scm_tan(z: SCM) -> SCM;
    pub fn scm_sinh(z: SCM) -> SCM;
    pub fn scm_cosh(z: SCM) -> SCM;
    pub fn scm_tanh(z: SCM) -> SCM;
    pub fn scm_asin(z: SCM) -> SCM;
    pub fn scm_acos(z: SCM) -> SCM;
    pub fn scm_atan(x: SCM, y: SCM) -> SCM;
    pub fn scm_sys_asinh(z: SCM) -> SCM;
    pub fn scm_sys_acosh(z: SCM) -> SCM;
    pub fn scm_sys_atanh(z: SCM) -> SCM;
    pub fn scm_make_rectangular(z1: SCM, z2: SCM) -> SCM;
    pub fn scm_make_polar(z1: SCM, z2: SCM) -> SCM;
    pub fn scm_real_part(z: SCM) -> SCM;
    pub fn scm_imag_part(z: SCM) -> SCM;
    pub fn scm_magnitude(z: SCM) -> SCM;
    pub fn scm_angle(z: SCM) -> SCM;
    pub fn scm_exact_to_inexact(z: SCM) -> SCM;
    pub fn scm_inexact_to_exact(z: SCM) -> SCM;
    pub fn scm_trunc(x: SCM) -> SCM;
    pub fn scm_log(z: SCM) -> SCM;
    pub fn scm_log10(z: SCM) -> SCM;
    pub fn scm_exp(z: SCM) -> SCM;
    pub fn scm_sqrt(z: SCM) -> SCM;
    pub fn scm_exact_integer_sqrt(k: SCM, s: *mut SCM, r: *mut SCM);
    pub fn scm_i_min(x: SCM, y: SCM, rest: SCM) -> SCM;
    pub fn scm_i_max(x: SCM, y: SCM, rest: SCM) -> SCM;
    pub fn scm_i_sum(x: SCM, y: SCM, rest: SCM) -> SCM;
    pub fn scm_i_difference(x: SCM, y: SCM, rest: SCM) -> SCM;
    pub fn scm_i_product(x: SCM, y: SCM, rest: SCM) -> SCM;
    pub fn scm_i_divide(x: SCM, y: SCM, rest: SCM) -> SCM;
    pub fn scm_i_exact_integer_sqrt(k: SCM) -> SCM;
    pub fn scm_i_mkbig() -> SCM;
    pub fn scm_i_normbig(x: SCM) -> SCM;
    pub fn scm_i_bigcmp(a: SCM, b: SCM) -> c_int;
    pub fn scm_i_dbl2big(d: c_double) -> SCM;
    pub fn scm_i_dbl2num(d: c_double) -> SCM;
    pub fn scm_i_big2dbl(b: SCM) -> c_double;
    pub fn scm_i_long2big(n: c_long) -> SCM;
    pub fn scm_i_ulong2big(n: c_ulong) -> SCM;
    pub fn scm_i_clonebig(src_big: SCM, same_sign_p: c_int)
     -> SCM;
    pub fn scm_rationalize(x: SCM, err: SCM) -> SCM;
    pub fn scm_numerator(z: SCM) -> SCM;
    pub fn scm_denominator(z: SCM) -> SCM;
    pub fn scm_i_fraction2double(z: SCM) -> c_double;
    pub fn scm_i_fraction_equalp(x: SCM, y: SCM) -> SCM;
    pub fn scm_i_print_fraction(sexp: SCM, port: SCM,
                                pstate: *mut scm_print_state)
     -> c_int;
    pub fn scm_i_print_double(val: c_double, port: SCM);
    pub fn scm_i_print_complex(real: c_double,
                               imag: c_double, port: SCM);
    pub fn scm_is_integer(val: SCM) -> c_int;
    pub fn scm_is_exact_integer(val: SCM) -> c_int;
    pub fn scm_is_signed_integer(val: SCM, min: scm_t_intmax,
                                 max: scm_t_intmax) -> c_int;
    pub fn scm_is_unsigned_integer(val: SCM, min: scm_t_uintmax,
                                   max: scm_t_uintmax)
     -> c_int;
    pub fn scm_from_signed_integer(val: scm_t_intmax) -> SCM;
    pub fn scm_from_unsigned_integer(val: scm_t_uintmax) -> SCM;
    pub fn scm_to_signed_integer(val: SCM, min: scm_t_intmax,
                                 max: scm_t_intmax) -> scm_t_intmax;
    pub fn scm_to_unsigned_integer(val: SCM, min: scm_t_uintmax,
                                   max: scm_t_uintmax) -> scm_t_uintmax;
    pub fn scm_to_int8(x: SCM) -> scm_t_int8;
    pub fn scm_from_int8(x: scm_t_int8) -> SCM;
    pub fn scm_to_uint8(x: SCM) -> scm_t_uint8;
    pub fn scm_from_uint8(x: scm_t_uint8) -> SCM;
    pub fn scm_to_int16(x: SCM) -> scm_t_int16;
    pub fn scm_from_int16(x: scm_t_int16) -> SCM;
    pub fn scm_to_uint16(x: SCM) -> scm_t_uint16;
    pub fn scm_from_uint16(x: scm_t_uint16) -> SCM;
    pub fn scm_to_int32(x: SCM) -> scm_t_int32;
    pub fn scm_from_int32(x: scm_t_int32) -> SCM;
    pub fn scm_to_uint32(x: SCM) -> scm_t_uint32;
    pub fn scm_from_uint32(x: scm_t_uint32) -> SCM;
    pub fn scm_to_wchar(x: SCM) -> scm_t_wchar;
    pub fn scm_from_wchar(x: scm_t_wchar) -> SCM;
    pub fn scm_to_int64(x: SCM) -> scm_t_int64;
    pub fn scm_from_int64(x: scm_t_int64) -> SCM;
    pub fn scm_to_uint64(x: SCM) -> scm_t_uint64;
    pub fn scm_from_uint64(x: scm_t_uint64) -> SCM;
    pub fn scm_to_mpz(x: SCM, rop: mpz_t);
    pub fn scm_from_mpz(rop: mpz_t) -> SCM;
    pub fn scm_is_real(val: SCM) -> c_int;
    pub fn scm_is_rational(val: SCM) -> c_int;
    pub fn scm_to_double(val: SCM) -> c_double;
    pub fn scm_from_double(val: c_double) -> SCM;
    pub fn scm_is_complex(val: SCM) -> c_int;
    pub fn scm_c_make_rectangular(re: c_double,
                                  im: c_double) -> SCM;
    pub fn scm_c_make_polar(mag: c_double,
                            ang: c_double) -> SCM;
    pub fn scm_c_real_part(z: SCM) -> c_double;
    pub fn scm_c_imag_part(z: SCM) -> c_double;
    pub fn scm_c_magnitude(z: SCM) -> c_double;
    pub fn scm_c_angle(z: SCM) -> c_double;
    pub fn scm_is_number(val: SCM) -> c_int;
    pub fn scm_init_numbers();
    pub fn scm_i_register_array_implementation(_impl:
                                                   *mut scm_t_array_implementation);
    pub fn scm_i_array_implementation_for_obj(obj: SCM)
     -> *mut scm_t_array_implementation;
    pub fn scm_array_get_handle(array: SCM, h: *mut scm_t_array_handle);
    pub fn scm_array_handle_pos(h: *mut scm_t_array_handle, indices: SCM)
     -> ssize_t;
    pub fn scm_array_handle_pos_1(h: *mut scm_t_array_handle, idx0: ssize_t)
     -> ssize_t;
    pub fn scm_array_handle_pos_2(h: *mut scm_t_array_handle, idx0: ssize_t,
                                  idx1: ssize_t) -> ssize_t;
    pub fn scm_array_handle_element_type(h: *mut scm_t_array_handle) -> SCM;
    pub fn scm_array_handle_release(h: *mut scm_t_array_handle);
    pub fn scm_array_handle_elements(h: *mut scm_t_array_handle)
     -> *const SCM;
    pub fn scm_array_handle_writable_elements(h: *mut scm_t_array_handle)
     -> *mut SCM;
    pub fn scm_array_handle_ref(h: *mut scm_t_array_handle, p: ssize_t)
     -> SCM;
    pub fn scm_array_handle_set(h: *mut scm_t_array_handle, p: ssize_t,
                                v: SCM);
    pub fn scm_init_array_handle();
    pub fn scm_ra_matchp(ra0: SCM, ras: SCM) -> c_int;
    pub fn scm_ramapc(cproc: *mut c_void, data: SCM, ra0: SCM,
                      lra: SCM, what: *const c_char)
     -> c_int;
    pub fn scm_array_fill_x(ra: SCM, fill: SCM) -> SCM;
    pub fn scm_array_copy_x(src: SCM, dst: SCM) -> SCM;
    pub fn scm_array_map_x(ra0: SCM, _proc: SCM, lra: SCM) -> SCM;
    pub fn scm_array_for_each(_proc: SCM, ra0: SCM, lra: SCM) -> SCM;
    pub fn scm_array_index_map_x(ra: SCM, _proc: SCM) -> SCM;
    pub fn scm_array_equal_p(ra0: SCM, ra1: SCM) -> SCM;
    pub fn scm_init_array_map();
    pub fn scm_array_fill_int(ra: SCM, fill: SCM, ignore: SCM)
     -> c_int;
    pub fn scm_ra_eqp(ra0: SCM, ras: SCM) -> c_int;
    pub fn scm_ra_lessp(ra0: SCM, ras: SCM) -> c_int;
    pub fn scm_ra_leqp(ra0: SCM, ras: SCM) -> c_int;
    pub fn scm_ra_grp(ra0: SCM, ras: SCM) -> c_int;
    pub fn scm_ra_greqp(ra0: SCM, ras: SCM) -> c_int;
    pub fn scm_ra_sum(ra0: SCM, ras: SCM) -> c_int;
    pub fn scm_ra_difference(ra0: SCM, ras: SCM) -> c_int;
    pub fn scm_ra_product(ra0: SCM, ras: SCM) -> c_int;
    pub fn scm_ra_divide(ra0: SCM, ras: SCM) -> c_int;
    pub fn scm_array_identity(src: SCM, dst: SCM) -> c_int;
    pub fn scm_make_array(fill: SCM, bounds: SCM) -> SCM;
    pub fn scm_from_contiguous_array(bounds: SCM, elts: *const SCM,
                                     len: size_t) -> SCM;
    pub fn scm_make_typed_array(_type: SCM, fill: SCM, bounds: SCM) -> SCM;
    pub fn scm_from_contiguous_typed_array(_type: SCM, bounds: SCM,
                                           bytes:
                                               *const c_void,
                                           byte_len: size_t) -> SCM;
    pub fn scm_shared_array_root(ra: SCM) -> SCM;
    pub fn scm_shared_array_offset(ra: SCM) -> SCM;
    pub fn scm_shared_array_increments(ra: SCM) -> SCM;
    pub fn scm_make_shared_array(oldra: SCM, mapfunc: SCM, dims: SCM) -> SCM;
    pub fn scm_transpose_array(ra: SCM, args: SCM) -> SCM;
    pub fn scm_array_contents(ra: SCM, strict: SCM) -> SCM;
    pub fn scm_list_to_array(ndim: SCM, lst: SCM) -> SCM;
    pub fn scm_list_to_typed_array(_type: SCM, ndim: SCM, lst: SCM) -> SCM;
    pub fn scm_i_make_array(ndim: c_int) -> SCM;
    pub fn scm_i_print_array(array: SCM, port: SCM,
                             pstate: *mut scm_print_state)
     -> c_int;
    pub fn scm_init_arrays();
    pub fn scm_local_eval(exp: SCM, env: SCM) -> SCM;
    pub fn scm_reverse_lookup(env: SCM, data: SCM) -> SCM;
    pub fn scm_procedure_source(_proc: SCM) -> SCM;
    pub fn scm_procedure_name(_proc: SCM) -> SCM;
    pub fn scm_debug_options(setting: SCM) -> SCM;
    pub fn scm_init_debug();
    pub fn scm_c_catch(tag: SCM, body: scm_t_catch_body,
                       body_data: *mut c_void,
                       handler: scm_t_catch_handler,
                       handler_data: *mut c_void,
                       pre_unwind_handler: scm_t_catch_handler,
                       pre_unwind_handler_data: *mut c_void)
     -> SCM;
    pub fn scm_c_with_throw_handler(tag: SCM, body: scm_t_catch_body,
                                    body_data: *mut c_void,
                                    handler: scm_t_catch_handler,
                                    handler_data: *mut c_void,
                                    lazy_catch_p: c_int)
     -> SCM;
    pub fn scm_internal_catch(tag: SCM, body: scm_t_catch_body,
                              body_data: *mut c_void,
                              handler: scm_t_catch_handler,
                              handler_data: *mut c_void)
     -> SCM;
    pub fn scm_body_thunk(arg1: *mut c_void) -> SCM;
    pub fn scm_handle_by_proc(arg1: *mut c_void, arg2: SCM,
                              arg3: SCM) -> SCM;
    pub fn scm_handle_by_proc_catching_all(arg1: *mut c_void,
                                           arg2: SCM, arg3: SCM) -> SCM;
    pub fn scm_handle_by_message(arg1: *mut c_void, arg2: SCM,
                                 arg3: SCM) -> SCM;
    pub fn scm_handle_by_message_noexit(arg1: *mut c_void,
                                        arg2: SCM, arg3: SCM) -> SCM;
    pub fn scm_handle_by_throw(arg1: *mut c_void, arg2: SCM,
                               arg3: SCM) -> SCM;
    pub fn scm_exit_status(args: SCM) -> c_int;
    pub fn scm_catch_with_pre_unwind_handler(tag: SCM, thunk: SCM,
                                             handler: SCM, lazy_handler: SCM)
     -> SCM;
    pub fn scm_catch(tag: SCM, thunk: SCM, handler: SCM) -> SCM;
    pub fn scm_with_throw_handler(tag: SCM, thunk: SCM, handler: SCM) -> SCM;
    pub fn scm_ithrow(key: SCM, args: SCM, no_return: c_int)
     -> SCM;
    pub fn scm_throw(key: SCM, args: SCM) -> SCM;
    pub fn scm_init_throw();
    pub fn scm_internal_cwdr(body: scm_t_catch_body,
                             body_data: *mut c_void,
                             handler: scm_t_catch_handler,
                             handler_data: *mut c_void,
                             stack_start: *mut SCM_STACKITEM) -> SCM;
    pub fn scm_call_with_dynamic_root(thunk: SCM, handler: SCM) -> SCM;
    pub fn scm_dynamic_root() -> SCM;
    pub fn scm_apply_with_dynamic_root(_proc: SCM, a1: SCM, args: SCM,
                                       handler: SCM) -> SCM;
    pub fn scm_init_root();
    pub fn scm_procedure_p(obj: SCM) -> SCM;
    pub fn scm_thunk_p(obj: SCM) -> SCM;
    pub fn scm_procedure_documentation(_proc: SCM) -> SCM;
    pub fn scm_procedure_with_setter_p(obj: SCM) -> SCM;
    pub fn scm_make_procedure_with_setter(procedure: SCM, setter: SCM) -> SCM;
    pub fn scm_procedure(_proc: SCM) -> SCM;
    pub fn scm_setter(_proc: SCM) -> SCM;
    pub fn scm_init_procs();
    pub fn scm_std_select(fds: c_int, rfds: *mut fd_set,
                          wfds: *mut fd_set, efds: *mut fd_set,
                          timeout: *mut Struct_timeval)
     -> c_int;
    pub fn scm_dynamic_wind(thunk1: SCM, thunk2: SCM, thunk3: SCM) -> SCM;
    pub fn scm_dowinds(to: SCM, delta: c_long);
    pub fn scm_i_dowinds(to: SCM, delta: c_long,
                         turn_func:
                             ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                            *mut c_void)>,
                         data: *mut c_void);
    pub fn scm_init_dynwind();
    pub fn scm_swap_bindings(vars: SCM, vals: SCM);
    pub fn scm_dynwind_begin(arg1: scm_t_dynwind_flags);
    pub fn scm_dynwind_end();
    pub fn scm_dynwind_unwind_handler(func:
                                          ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                                         *mut c_void)>,
                                      data: *mut c_void,
                                      arg1: scm_t_wind_flags);
    pub fn scm_dynwind_rewind_handler(func:
                                          ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                                         *mut c_void)>,
                                      data: *mut c_void,
                                      arg1: scm_t_wind_flags);
    pub fn scm_dynwind_unwind_handler_with_scm(func:
                                                   ::std::option::Option<extern "C" fn(arg1:
                                                                                           SCM)>,
                                               data: SCM,
                                               arg1: scm_t_wind_flags);
    pub fn scm_dynwind_rewind_handler_with_scm(func:
                                                   ::std::option::Option<extern "C" fn(arg1:
                                                                                           SCM)>,
                                               data: SCM,
                                               arg1: scm_t_wind_flags);
    pub fn scm_dynwind_free(mem: *mut c_void);
    pub fn scm_i_make_continuation(first: *mut c_int, vm: SCM,
                                   vm_cont: SCM) -> SCM;
    pub fn scm_i_check_continuation(cont: SCM);
    pub fn scm_i_reinstate_continuation(cont: SCM);
    pub fn scm_i_call_with_current_continuation(_proc: SCM) -> SCM;
    pub fn scm_i_continuation_to_frame(cont: SCM) -> SCM;
    pub fn scm_i_contregs_vm(contregs: SCM) -> SCM;
    pub fn scm_i_contregs_vm_cont(contregs: SCM) -> SCM;
    pub fn scm_c_with_continuation_barrier(func:
                                               ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                                              *mut c_void)
                                                                         ->
                                                                             *mut c_void>,
                                           arg1: *mut c_void)
     -> *mut c_void;
    pub fn scm_with_continuation_barrier(_proc: SCM) -> SCM;
    pub fn scm_i_with_continuation_barrier(body: scm_t_catch_body,
                                           body_data:
                                               *mut c_void,
                                           handler: scm_t_catch_handler,
                                           handler_data:
                                               *mut c_void,
                                           pre_unwind_handler:
                                               scm_t_catch_handler,
                                           pre_unwind_handler_data:
                                               *mut c_void)
     -> SCM;
    pub fn scm_init_continuations();
    pub fn __sched_cpucount(__setsize: size_t, __setp: *const cpu_set_t)
     -> 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)
     -> c_int;
    pub fn sched_getparam(__pid: __pid_t, __param: *mut Struct_sched_param)
     -> c_int;
    pub fn sched_setscheduler(__pid: __pid_t, __policy: c_int,
                              __param: *const Struct_sched_param)
     -> c_int;
    pub fn sched_getscheduler(__pid: __pid_t) -> c_int;
    pub fn sched_yield() -> c_int;
    pub fn sched_get_priority_max(__algorithm: c_int)
     -> c_int;
    pub fn sched_get_priority_min(__algorithm: c_int)
     -> c_int;
    pub fn sched_rr_get_interval(__pid: __pid_t, __t: *mut Struct_timespec)
     -> c_int;
    pub fn pthread_create(__newthread: *mut pthread_t,
                          __attr: *const pthread_attr_t,
                          __start_routine:
                              ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                             *mut c_void)
                                                        ->
                                                            *mut c_void>,
                          __arg: *mut c_void)
     -> c_int;
    pub fn pthread_exit(__retval: *mut c_void);
    pub fn pthread_join(__th: pthread_t,
                        __thread_return: *mut *mut c_void)
     -> c_int;
    pub fn pthread_detach(__th: pthread_t) -> c_int;
    pub fn pthread_self() -> pthread_t;
    pub fn pthread_equal(__thread1: pthread_t, __thread2: pthread_t)
     -> c_int;
    pub fn pthread_attr_init(__attr: *mut pthread_attr_t)
     -> c_int;
    pub fn pthread_attr_destroy(__attr: *mut pthread_attr_t)
     -> c_int;
    pub fn pthread_attr_getdetachstate(__attr: *const pthread_attr_t,
                                       __detachstate:
                                           *mut c_int)
     -> c_int;
    pub fn pthread_attr_setdetachstate(__attr: *mut pthread_attr_t,
                                       __detachstate: c_int)
     -> c_int;
    pub fn pthread_attr_getguardsize(__attr: *const pthread_attr_t,
                                     __guardsize: *mut size_t)
     -> c_int;
    pub fn pthread_attr_setguardsize(__attr: *mut pthread_attr_t,
                                     __guardsize: size_t)
     -> c_int;
    pub fn pthread_attr_getschedparam(__attr: *const pthread_attr_t,
                                      __param: *mut Struct_sched_param)
     -> c_int;
    pub fn pthread_attr_setschedparam(__attr: *mut pthread_attr_t,
                                      __param: *const Struct_sched_param)
     -> c_int;
    pub fn pthread_attr_getschedpolicy(__attr: *const pthread_attr_t,
                                       __policy: *mut c_int)
     -> c_int;
    pub fn pthread_attr_setschedpolicy(__attr: *mut pthread_attr_t,
                                       __policy: c_int)
     -> c_int;
    pub fn pthread_attr_getinheritsched(__attr: *const pthread_attr_t,
                                        __inherit: *mut c_int)
     -> c_int;
    pub fn pthread_attr_setinheritsched(__attr: *mut pthread_attr_t,
                                        __inherit: c_int)
     -> c_int;
    pub fn pthread_attr_getscope(__attr: *const pthread_attr_t,
                                 __scope: *mut c_int)
     -> c_int;
    pub fn pthread_attr_setscope(__attr: *mut pthread_attr_t,
                                 __scope: c_int)
     -> c_int;
    pub fn pthread_attr_getstackaddr(__attr: *const pthread_attr_t,
                                     __stackaddr:
                                         *mut *mut c_void)
     -> c_int;
    pub fn pthread_attr_setstackaddr(__attr: *mut pthread_attr_t,
                                     __stackaddr: *mut c_void)
     -> c_int;
    pub fn pthread_attr_getstacksize(__attr: *const pthread_attr_t,
                                     __stacksize: *mut size_t)
     -> c_int;
    pub fn pthread_attr_setstacksize(__attr: *mut pthread_attr_t,
                                     __stacksize: size_t)
     -> c_int;
    pub fn pthread_attr_getstack(__attr: *const pthread_attr_t,
                                 __stackaddr:
                                     *mut *mut c_void,
                                 __stacksize: *mut size_t)
     -> c_int;
    pub fn pthread_attr_setstack(__attr: *mut pthread_attr_t,
                                 __stackaddr: *mut c_void,
                                 __stacksize: size_t)
     -> c_int;
    pub fn pthread_setschedparam(__target_thread: pthread_t,
                                 __policy: c_int,
                                 __param: *const Struct_sched_param)
     -> c_int;
    pub fn pthread_getschedparam(__target_thread: pthread_t,
                                 __policy: *mut c_int,
                                 __param: *mut Struct_sched_param)
     -> c_int;
    pub fn pthread_setschedprio(__target_thread: pthread_t,
                                __prio: c_int)
     -> c_int;
    pub fn pthread_once(__once_control: *mut pthread_once_t,
                        __init_routine:
                            ::std::option::Option<extern "C" fn()>)
     -> c_int;
    pub fn pthread_setcancelstate(__state: c_int,
                                  __oldstate: *mut c_int)
     -> c_int;
    pub fn pthread_setcanceltype(__type: c_int,
                                 __oldtype: *mut c_int)
     -> c_int;
    pub fn pthread_cancel(__th: pthread_t) -> 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 pthread_mutex_init(__mutex: *mut pthread_mutex_t,
                              __mutexattr: *const pthread_mutexattr_t)
     -> c_int;
    pub fn pthread_mutex_destroy(__mutex: *mut pthread_mutex_t)
     -> c_int;
    pub fn pthread_mutex_trylock(__mutex: *mut pthread_mutex_t)
     -> c_int;
    pub fn pthread_mutex_lock(__mutex: *mut pthread_mutex_t)
     -> c_int;
    pub fn pthread_mutex_timedlock(__mutex: *mut pthread_mutex_t,
                                   __abstime: *const Struct_timespec)
     -> c_int;
    pub fn pthread_mutex_unlock(__mutex: *mut pthread_mutex_t)
     -> c_int;
    pub fn pthread_mutex_getprioceiling(__mutex: *const pthread_mutex_t,
                                        __prioceiling:
                                            *mut c_int)
     -> c_int;
    pub fn pthread_mutex_setprioceiling(__mutex: *mut pthread_mutex_t,
                                        __prioceiling: c_int,
                                        __old_ceiling:
                                            *mut c_int)
     -> c_int;
    pub fn pthread_mutex_consistent(__mutex: *mut pthread_mutex_t)
     -> c_int;
    pub fn pthread_mutexattr_init(__attr: *mut pthread_mutexattr_t)
     -> c_int;
    pub fn pthread_mutexattr_destroy(__attr: *mut pthread_mutexattr_t)
     -> c_int;
    pub fn pthread_mutexattr_getpshared(__attr: *const pthread_mutexattr_t,
                                        __pshared: *mut c_int)
     -> c_int;
    pub fn pthread_mutexattr_setpshared(__attr: *mut pthread_mutexattr_t,
                                        __pshared: c_int)
     -> c_int;
    pub fn pthread_mutexattr_gettype(__attr: *const pthread_mutexattr_t,
                                     __kind: *mut c_int)
     -> c_int;
    pub fn pthread_mutexattr_settype(__attr: *mut pthread_mutexattr_t,
                                     __kind: c_int)
     -> c_int;
    pub fn pthread_mutexattr_getprotocol(__attr: *const pthread_mutexattr_t,
                                         __protocol:
                                             *mut c_int)
     -> c_int;
    pub fn pthread_mutexattr_setprotocol(__attr: *mut pthread_mutexattr_t,
                                         __protocol: c_int)
     -> c_int;
    pub fn pthread_mutexattr_getprioceiling(__attr:
                                                *const pthread_mutexattr_t,
                                            __prioceiling:
                                                *mut c_int)
     -> c_int;
    pub fn pthread_mutexattr_setprioceiling(__attr: *mut pthread_mutexattr_t,
                                            __prioceiling:
                                                c_int)
     -> c_int;
    pub fn pthread_mutexattr_getrobust(__attr: *const pthread_mutexattr_t,
                                       __robustness:
                                           *mut c_int)
     -> c_int;
    pub fn pthread_mutexattr_setrobust(__attr: *mut pthread_mutexattr_t,
                                       __robustness: c_int)
     -> c_int;
    pub fn pthread_rwlock_init(__rwlock: *mut pthread_rwlock_t,
                               __attr: *const pthread_rwlockattr_t)
     -> c_int;
    pub fn pthread_rwlock_destroy(__rwlock: *mut pthread_rwlock_t)
     -> c_int;
    pub fn pthread_rwlock_rdlock(__rwlock: *mut pthread_rwlock_t)
     -> c_int;
    pub fn pthread_rwlock_tryrdlock(__rwlock: *mut pthread_rwlock_t)
     -> c_int;
    pub fn pthread_rwlock_timedrdlock(__rwlock: *mut pthread_rwlock_t,
                                      __abstime: *const Struct_timespec)
     -> c_int;
    pub fn pthread_rwlock_wrlock(__rwlock: *mut pthread_rwlock_t)
     -> c_int;
    pub fn pthread_rwlock_trywrlock(__rwlock: *mut pthread_rwlock_t)
     -> c_int;
    pub fn pthread_rwlock_timedwrlock(__rwlock: *mut pthread_rwlock_t,
                                      __abstime: *const Struct_timespec)
     -> c_int;
    pub fn pthread_rwlock_unlock(__rwlock: *mut pthread_rwlock_t)
     -> c_int;
    pub fn pthread_rwlockattr_init(__attr: *mut pthread_rwlockattr_t)
     -> c_int;
    pub fn pthread_rwlockattr_destroy(__attr: *mut pthread_rwlockattr_t)
     -> c_int;
    pub fn pthread_rwlockattr_getpshared(__attr: *const pthread_rwlockattr_t,
                                         __pshared:
                                             *mut c_int)
     -> c_int;
    pub fn pthread_rwlockattr_setpshared(__attr: *mut pthread_rwlockattr_t,
                                         __pshared: c_int)
     -> c_int;
    pub fn pthread_rwlockattr_getkind_np(__attr: *const pthread_rwlockattr_t,
                                         __pref: *mut c_int)
     -> c_int;
    pub fn pthread_rwlockattr_setkind_np(__attr: *mut pthread_rwlockattr_t,
                                         __pref: c_int)
     -> c_int;
    pub fn pthread_cond_init(__cond: *mut pthread_cond_t,
                             __cond_attr: *const pthread_condattr_t)
     -> c_int;
    pub fn pthread_cond_destroy(__cond: *mut pthread_cond_t)
     -> c_int;
    pub fn pthread_cond_signal(__cond: *mut pthread_cond_t)
     -> c_int;
    pub fn pthread_cond_broadcast(__cond: *mut pthread_cond_t)
     -> c_int;
    pub fn pthread_cond_wait(__cond: *mut pthread_cond_t,
                             __mutex: *mut pthread_mutex_t)
     -> c_int;
    pub fn pthread_cond_timedwait(__cond: *mut pthread_cond_t,
                                  __mutex: *mut pthread_mutex_t,
                                  __abstime: *const Struct_timespec)
     -> c_int;
    pub fn pthread_condattr_init(__attr: *mut pthread_condattr_t)
     -> c_int;
    pub fn pthread_condattr_destroy(__attr: *mut pthread_condattr_t)
     -> c_int;
    pub fn pthread_condattr_getpshared(__attr: *const pthread_condattr_t,
                                       __pshared: *mut c_int)
     -> c_int;
    pub fn pthread_condattr_setpshared(__attr: *mut pthread_condattr_t,
                                       __pshared: c_int)
     -> c_int;
    pub fn pthread_condattr_getclock(__attr: *const pthread_condattr_t,
                                     __clock_id: *mut __clockid_t)
     -> c_int;
    pub fn pthread_condattr_setclock(__attr: *mut pthread_condattr_t,
                                     __clock_id: __clockid_t)
     -> c_int;
    pub fn pthread_spin_init(__lock: *mut pthread_spinlock_t,
                             __pshared: c_int)
     -> c_int;
    pub fn pthread_spin_destroy(__lock: *mut pthread_spinlock_t)
     -> c_int;
    pub fn pthread_spin_lock(__lock: *mut pthread_spinlock_t)
     -> c_int;
    pub fn pthread_spin_trylock(__lock: *mut pthread_spinlock_t)
     -> c_int;
    pub fn pthread_spin_unlock(__lock: *mut pthread_spinlock_t)
     -> c_int;
    pub fn pthread_barrier_init(__barrier: *mut pthread_barrier_t,
                                __attr: *const pthread_barrierattr_t,
                                __count: c_uint)
     -> c_int;
    pub fn pthread_barrier_destroy(__barrier: *mut pthread_barrier_t)
     -> c_int;
    pub fn pthread_barrier_wait(__barrier: *mut pthread_barrier_t)
     -> c_int;
    pub fn pthread_barrierattr_init(__attr: *mut pthread_barrierattr_t)
     -> c_int;
    pub fn pthread_barrierattr_destroy(__attr: *mut pthread_barrierattr_t)
     -> c_int;
    pub fn pthread_barrierattr_getpshared(__attr:
                                              *const pthread_barrierattr_t,
                                          __pshared:
                                              *mut c_int)
     -> c_int;
    pub fn pthread_barrierattr_setpshared(__attr: *mut pthread_barrierattr_t,
                                          __pshared: c_int)
     -> c_int;
    pub fn pthread_key_create(__key: *mut pthread_key_t,
                              __destr_function:
                                  ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                                 *mut c_void)>)
     -> c_int;
    pub fn pthread_key_delete(__key: pthread_key_t) -> c_int;
    pub fn pthread_getspecific(__key: pthread_key_t)
     -> *mut c_void;
    pub fn pthread_setspecific(__key: pthread_key_t,
                               __pointer: *const c_void)
     -> c_int;
    pub fn pthread_getcpuclockid(__thread_id: pthread_t,
                                 __clock_id: *mut __clockid_t)
     -> 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()>)
     -> c_int;
    pub fn GC_get_version() -> c_uint;
    pub fn GC_get_gc_no() -> GC_word;
    pub fn GC_get_parallel() -> c_int;
    pub fn GC_set_oom_fn(arg1: GC_oom_func);
    pub fn GC_get_oom_fn() -> GC_oom_func;
    pub fn GC_set_on_heap_resize(arg1: GC_on_heap_resize_proc);
    pub fn GC_get_on_heap_resize() -> GC_on_heap_resize_proc;
    pub fn GC_set_find_leak(arg1: c_int);
    pub fn GC_get_find_leak() -> c_int;
    pub fn GC_set_all_interior_pointers(arg1: c_int);
    pub fn GC_get_all_interior_pointers() -> c_int;
    pub fn GC_set_finalize_on_demand(arg1: c_int);
    pub fn GC_get_finalize_on_demand() -> c_int;
    pub fn GC_set_java_finalization(arg1: c_int);
    pub fn GC_get_java_finalization() -> c_int;
    pub fn GC_set_finalizer_notifier(arg1: GC_finalizer_notifier_proc);
    pub fn GC_get_finalizer_notifier() -> GC_finalizer_notifier_proc;
    pub fn GC_set_dont_expand(arg1: c_int);
    pub fn GC_get_dont_expand() -> c_int;
    pub fn GC_set_full_freq(arg1: c_int);
    pub fn GC_get_full_freq() -> c_int;
    pub fn GC_set_non_gc_bytes(arg1: GC_word);
    pub fn GC_get_non_gc_bytes() -> GC_word;
    pub fn GC_set_no_dls(arg1: c_int);
    pub fn GC_get_no_dls() -> c_int;
    pub fn GC_set_free_space_divisor(arg1: GC_word);
    pub fn GC_get_free_space_divisor() -> GC_word;
    pub fn GC_set_max_retries(arg1: GC_word);
    pub fn GC_get_max_retries() -> GC_word;
    pub fn GC_set_dont_precollect(arg1: c_int);
    pub fn GC_get_dont_precollect() -> c_int;
    pub fn GC_set_time_limit(arg1: c_ulong);
    pub fn GC_get_time_limit() -> c_ulong;
    pub fn GC_set_pages_executable(arg1: c_int);
    pub fn GC_get_pages_executable() -> c_int;
    pub fn GC_set_handle_fork(arg1: c_int);
    pub fn GC_atfork_prepare();
    pub fn GC_atfork_parent();
    pub fn GC_atfork_child();
    pub fn GC_init();
    pub fn GC_malloc(arg1: size_t) -> *mut c_void;
    pub fn GC_malloc_atomic(arg1: size_t) -> *mut c_void;
    pub fn GC_strdup(arg1: *const c_char)
     -> *mut c_char;
    pub fn GC_strndup(arg1: *const c_char, arg2: size_t)
     -> *mut c_char;
    pub fn GC_malloc_uncollectable(arg1: size_t)
     -> *mut c_void;
    pub fn GC_malloc_stubborn(arg1: size_t) -> *mut c_void;
    pub fn GC_memalign(arg1: size_t, arg2: size_t)
     -> *mut c_void;
    pub fn GC_posix_memalign(arg1: *mut *mut c_void,
                             arg2: size_t, arg3: size_t)
     -> c_int;
    pub fn GC_free(arg1: *mut c_void);
    pub fn GC_change_stubborn(arg1: *const c_void);
    pub fn GC_end_stubborn_change(arg1: *const c_void);
    pub fn GC_base(arg1: *mut c_void)
     -> *mut c_void;
    pub fn GC_is_heap_ptr(arg1: *const c_void)
     -> c_int;
    pub fn GC_size(arg1: *const c_void) -> size_t;
    pub fn GC_realloc(arg1: *mut c_void, arg2: size_t)
     -> *mut c_void;
    pub fn GC_expand_hp(arg1: size_t) -> c_int;
    pub fn GC_set_max_heap_size(arg1: GC_word);
    pub fn GC_exclude_static_roots(arg1: *mut c_void,
                                   arg2: *mut c_void);
    pub fn GC_clear_roots();
    pub fn GC_add_roots(arg1: *mut c_void,
                        arg2: *mut c_void);
    pub fn GC_remove_roots(arg1: *mut c_void,
                           arg2: *mut c_void);
    pub fn GC_register_displacement(arg1: size_t);
    pub fn GC_debug_register_displacement(arg1: size_t);
    pub fn GC_gcollect();
    pub fn GC_gcollect_and_unmap();
    pub fn GC_try_to_collect(arg1: GC_stop_func) -> c_int;
    pub fn GC_set_stop_func(arg1: GC_stop_func);
    pub fn GC_get_stop_func() -> GC_stop_func;
    pub fn GC_get_heap_size() -> size_t;
    pub fn GC_get_free_bytes() -> size_t;
    pub fn GC_get_unmapped_bytes() -> size_t;
    pub fn GC_get_bytes_since_gc() -> size_t;
    pub fn GC_get_total_bytes() -> size_t;
    pub fn GC_get_heap_usage_safe(arg1: *mut GC_word, arg2: *mut GC_word,
                                  arg3: *mut GC_word, arg4: *mut GC_word,
                                  arg5: *mut GC_word);
    pub fn GC_get_prof_stats(arg1: *mut Struct_GC_prof_stats_s, arg2: size_t)
     -> size_t;
    pub fn GC_get_prof_stats_unsafe(arg1: *mut Struct_GC_prof_stats_s,
                                    arg2: size_t) -> size_t;
    pub fn GC_disable();
    pub fn GC_is_disabled() -> c_int;
    pub fn GC_enable();
    pub fn GC_enable_incremental();
    pub fn GC_incremental_protection_needs() -> c_int;
    pub fn GC_collect_a_little() -> c_int;
    pub fn GC_malloc_ignore_off_page(arg1: size_t)
     -> *mut c_void;
    pub fn GC_malloc_atomic_ignore_off_page(arg1: size_t)
     -> *mut c_void;
    pub fn GC_malloc_atomic_uncollectable(arg1: size_t)
     -> *mut c_void;
    pub fn GC_debug_malloc_atomic_uncollectable(arg1: size_t,
                                                s:
                                                    *const c_char,
                                                i: c_int)
     -> *mut c_void;
    pub fn GC_debug_malloc(arg1: size_t, s: *const c_char,
                           i: c_int)
     -> *mut c_void;
    pub fn GC_debug_malloc_atomic(arg1: size_t,
                                  s: *const c_char,
                                  i: c_int)
     -> *mut c_void;
    pub fn GC_debug_strdup(arg1: *const c_char,
                           s: *const c_char,
                           i: c_int)
     -> *mut c_char;
    pub fn GC_debug_strndup(arg1: *const c_char, arg2: size_t,
                            s: *const c_char,
                            i: c_int)
     -> *mut c_char;
    pub fn GC_debug_malloc_uncollectable(arg1: size_t,
                                         s: *const c_char,
                                         i: c_int)
     -> *mut c_void;
    pub fn GC_debug_malloc_stubborn(arg1: size_t,
                                    s: *const c_char,
                                    i: c_int)
     -> *mut c_void;
    pub fn GC_debug_malloc_ignore_off_page(arg1: size_t,
                                           s: *const c_char,
                                           i: c_int)
     -> *mut c_void;
    pub fn GC_debug_malloc_atomic_ignore_off_page(arg1: size_t,
                                                  s:
                                                      *const c_char,
                                                  i: c_int)
     -> *mut c_void;
    pub fn GC_debug_free(arg1: *mut c_void);
    pub fn GC_debug_realloc(arg1: *mut c_void, arg2: size_t,
                            s: *const c_char,
                            i: c_int)
     -> *mut c_void;
    pub fn GC_debug_change_stubborn(arg1: *const c_void);
    pub fn GC_debug_end_stubborn_change(arg1: *const c_void);
    pub fn GC_debug_malloc_replacement(arg1: size_t)
     -> *mut c_void;
    pub fn GC_debug_realloc_replacement(arg1: *mut c_void,
                                        arg2: size_t)
     -> *mut c_void;
    pub fn GC_register_finalizer(arg1: *mut c_void,
                                 arg2: GC_finalization_proc,
                                 arg3: *mut c_void,
                                 arg4: *mut GC_finalization_proc,
                                 arg5: *mut *mut c_void);
    pub fn GC_debug_register_finalizer(arg1: *mut c_void,
                                       arg2: GC_finalization_proc,
                                       arg3: *mut c_void,
                                       arg4: *mut GC_finalization_proc,
                                       arg5:
                                           *mut *mut c_void);
    pub fn GC_register_finalizer_ignore_self(arg1:
                                                 *mut c_void,
                                             arg2: GC_finalization_proc,
                                             arg3:
                                                 *mut c_void,
                                             arg4: *mut GC_finalization_proc,
                                             arg5:
                                                 *mut *mut c_void);
    pub fn GC_debug_register_finalizer_ignore_self(arg1:
                                                       *mut c_void,
                                                   arg2: GC_finalization_proc,
                                                   arg3:
                                                       *mut c_void,
                                                   arg4:
                                                       *mut GC_finalization_proc,
                                                   arg5:
                                                       *mut *mut c_void);
    pub fn GC_register_finalizer_no_order(arg1: *mut c_void,
                                          arg2: GC_finalization_proc,
                                          arg3: *mut c_void,
                                          arg4: *mut GC_finalization_proc,
                                          arg5:
                                              *mut *mut c_void);
    pub fn GC_debug_register_finalizer_no_order(arg1:
                                                    *mut c_void,
                                                arg2: GC_finalization_proc,
                                                arg3:
                                                    *mut c_void,
                                                arg4:
                                                    *mut GC_finalization_proc,
                                                arg5:
                                                    *mut *mut c_void);
    pub fn GC_register_finalizer_unreachable(arg1:
                                                 *mut c_void,
                                             arg2: GC_finalization_proc,
                                             arg3:
                                                 *mut c_void,
                                             arg4: *mut GC_finalization_proc,
                                             arg5:
                                                 *mut *mut c_void);
    pub fn GC_debug_register_finalizer_unreachable(arg1:
                                                       *mut c_void,
                                                   arg2: GC_finalization_proc,
                                                   arg3:
                                                       *mut c_void,
                                                   arg4:
                                                       *mut GC_finalization_proc,
                                                   arg5:
                                                       *mut *mut c_void);
    pub fn GC_register_disappearing_link(arg1:
                                             *mut *mut c_void)
     -> c_int;
    pub fn GC_general_register_disappearing_link(arg1:
                                                     *mut *mut c_void,
                                                 arg2:
                                                     *const c_void)
     -> c_int;
    pub fn GC_move_disappearing_link(arg1: *mut *mut c_void,
                                     arg2: *mut *mut c_void)
     -> c_int;
    pub fn GC_unregister_disappearing_link(arg1:
                                               *mut *mut c_void)
     -> c_int;
    pub fn GC_register_long_link(arg1: *mut *mut c_void,
                                 arg2: *const c_void)
     -> c_int;
    pub fn GC_move_long_link(arg1: *mut *mut c_void,
                             arg2: *mut *mut c_void)
     -> c_int;
    pub fn GC_unregister_long_link(arg1: *mut *mut c_void)
     -> c_int;
    pub fn GC_should_invoke_finalizers() -> c_int;
    pub fn GC_invoke_finalizers() -> c_int;
    pub fn GC_set_warn_proc(arg1: GC_warn_proc);
    pub fn GC_get_warn_proc() -> GC_warn_proc;
    pub fn GC_ignore_warn_proc(arg1: *mut c_char,
                               arg2: GC_word);
    pub fn GC_set_abort_func(arg1: GC_abort_func);
    pub fn GC_get_abort_func() -> GC_abort_func;
    pub fn GC_call_with_alloc_lock(arg1: GC_fn_type,
                                   arg2: *mut c_void)
     -> *mut c_void;
    pub fn GC_call_with_stack_base(arg1: GC_stack_base_func,
                                   arg2: *mut c_void)
     -> *mut c_void;
    pub fn GC_set_suspend_signal(arg1: c_int);
    pub fn GC_set_thr_restart_signal(arg1: c_int);
    pub fn GC_get_suspend_signal() -> c_int;
    pub fn GC_get_thr_restart_signal() -> c_int;
    pub fn GC_start_mark_threads();
    pub fn GC_allow_register_threads();
    pub fn GC_register_my_thread(arg1: *const Struct_GC_stack_base)
     -> c_int;
    pub fn GC_thread_is_registered() -> c_int;
    pub fn GC_unregister_my_thread() -> c_int;
    pub fn GC_do_blocking(arg1: GC_fn_type, arg2: *mut c_void)
     -> *mut c_void;
    pub fn GC_call_with_gc_active(arg1: GC_fn_type,
                                  arg2: *mut c_void)
     -> *mut c_void;
    pub fn GC_get_stack_base(arg1: *mut Struct_GC_stack_base)
     -> c_int;
    pub fn GC_same_obj(arg1: *mut c_void,
                       arg2: *mut c_void)
     -> *mut c_void;
    pub fn GC_pre_incr(arg1: *mut *mut c_void,
                       arg2: ptrdiff_t) -> *mut c_void;
    pub fn GC_post_incr(arg1: *mut *mut c_void,
                        arg2: ptrdiff_t) -> *mut c_void;
    pub fn GC_is_visible(arg1: *mut c_void)
     -> *mut c_void;
    pub fn GC_is_valid_displacement(arg1: *mut c_void)
     -> *mut c_void;
    pub fn GC_dump();
    pub fn dlopen(__file: *const c_char,
                  __mode: c_int)
     -> *mut c_void;
    pub fn dlclose(__handle: *mut c_void)
     -> c_int;
    pub fn dlsym(__handle: *mut c_void,
                 __name: *const c_char)
     -> *mut c_void;
    pub fn dlerror() -> *mut c_char;
    pub fn GC_dlopen(arg1: *const c_char,
                     arg2: c_int)
     -> *mut c_void;
    pub fn __sigismember(arg1: *const __sigset_t, arg2: c_int)
     -> c_int;
    pub fn __sigaddset(arg1: *mut __sigset_t, arg2: c_int)
     -> c_int;
    pub fn __sigdelset(arg1: *mut __sigset_t, arg2: c_int)
     -> c_int;
    pub fn __sysv_signal(__sig: c_int,
                         __handler: __sighandler_t) -> __sighandler_t;
    pub fn signal(__sig: c_int, __handler: __sighandler_t)
     -> __sighandler_t;
    pub fn kill(__pid: __pid_t, __sig: c_int)
     -> c_int;
    pub fn killpg(__pgrp: __pid_t, __sig: c_int)
     -> c_int;
    pub fn raise(__sig: c_int) -> c_int;
    pub fn ssignal(__sig: c_int, __handler: __sighandler_t)
     -> __sighandler_t;
    pub fn gsignal(__sig: c_int) -> c_int;
    pub fn psignal(__sig: c_int,
                   __s: *const c_char);
    pub fn psiginfo(__pinfo: *const siginfo_t,
                    __s: *const c_char);
    pub fn sigblock(__mask: c_int) -> c_int;
    pub fn sigsetmask(__mask: c_int) -> c_int;
    pub fn siggetmask() -> c_int;
    pub fn sigemptyset(__set: *mut sigset_t) -> c_int;
    pub fn sigfillset(__set: *mut sigset_t) -> c_int;
    pub fn sigaddset(__set: *mut sigset_t, __signo: c_int)
     -> c_int;
    pub fn sigdelset(__set: *mut sigset_t, __signo: c_int)
     -> c_int;
    pub fn sigismember(__set: *const sigset_t, __signo: c_int)
     -> c_int;
    pub fn sigprocmask(__how: c_int, __set: *const sigset_t,
                       __oset: *mut sigset_t) -> c_int;
    pub fn sigsuspend(__set: *const sigset_t) -> c_int;
    pub fn sigaction(__sig: c_int,
                     __act: *const Struct_sigaction,
                     __oact: *mut Struct_sigaction) -> c_int;
    pub fn sigpending(__set: *mut sigset_t) -> c_int;
    pub fn sigwait(__set: *const sigset_t, __sig: *mut c_int)
     -> c_int;
    pub fn sigwaitinfo(__set: *const sigset_t, __info: *mut siginfo_t)
     -> c_int;
    pub fn sigtimedwait(__set: *const sigset_t, __info: *mut siginfo_t,
                        __timeout: *const Struct_timespec)
     -> c_int;
    pub fn sigqueue(__pid: __pid_t, __sig: c_int,
                    __val: Union_sigval) -> c_int;
    pub fn sigreturn(__scp: *mut Struct_sigcontext) -> c_int;
    pub fn siginterrupt(__sig: c_int,
                        __interrupt: c_int)
     -> c_int;
    pub fn sigstack(__ss: *mut Struct_sigstack, __oss: *mut Struct_sigstack)
     -> c_int;
    pub fn sigaltstack(__ss: *const Struct_sigaltstack,
                       __oss: *mut Struct_sigaltstack)
     -> c_int;
    pub fn pthread_sigmask(__how: c_int,
                           __newmask: *const __sigset_t,
                           __oldmask: *mut __sigset_t)
     -> c_int;
    pub fn pthread_kill(__threadid: pthread_t, __signo: c_int)
     -> c_int;
    pub fn __libc_current_sigrtmin() -> c_int;
    pub fn __libc_current_sigrtmax() -> c_int;
    pub fn GC_pthread_sigmask(arg1: c_int,
                              arg2: *const sigset_t, arg3: *mut sigset_t)
     -> c_int;
    pub fn GC_pthread_create(arg1: *mut pthread_t,
                             arg2: *const pthread_attr_t,
                             arg3:
                                 ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                                *mut c_void)
                                                           ->
                                                               *mut c_void>,
                             arg4: *mut c_void)
     -> c_int;
    pub fn GC_pthread_join(arg1: pthread_t,
                           arg2: *mut *mut c_void)
     -> c_int;
    pub fn GC_pthread_detach(arg1: pthread_t) -> c_int;
    pub fn GC_pthread_cancel(arg1: pthread_t) -> c_int;
    pub fn GC_pthread_exit(arg1: *mut c_void);
    pub fn GC_malloc_many(arg1: size_t) -> *mut c_void;
    pub fn GC_register_has_static_roots_callback(arg1:
                                                     GC_has_static_roots_func);
    pub fn GC_set_force_unmap_on_gcollect(arg1: c_int);
    pub fn GC_get_force_unmap_on_gcollect() -> c_int;
    pub fn GC_win32_free_heap();
    pub fn scm_spawn_thread(body: scm_t_catch_body,
                            body_data: *mut c_void,
                            handler: scm_t_catch_handler,
                            handler_data: *mut c_void) -> SCM;
    pub fn scm_without_guile(func:
                                 ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                                *mut c_void)
                                                           ->
                                                               *mut c_void>,
                             data: *mut c_void)
     -> *mut c_void;
    pub fn scm_with_guile(func:
                              ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                             *mut c_void)
                                                        ->
                                                            *mut c_void>,
                          data: *mut c_void)
     -> *mut c_void;
    pub fn scm_i_reset_fluid(arg1: size_t);
    pub fn scm_threads_prehistory(arg1: *mut c_void);
    pub fn scm_init_threads();
    pub fn scm_init_thread_procs();
    pub fn scm_init_threads_default_dynamic_state();
    pub fn scm_i_dynwind_pthread_mutex_lock_block_asyncs(mutex:
                                                             *mut pthread_mutex_t);
    pub fn scm_call_with_new_thread(thunk: SCM, handler: SCM) -> SCM;
    pub fn scm_yield() -> SCM;
    pub fn scm_cancel_thread(t: SCM) -> SCM;
    pub fn scm_set_thread_cleanup_x(thread: SCM, _proc: SCM) -> SCM;
    pub fn scm_thread_cleanup(thread: SCM) -> SCM;
    pub fn scm_join_thread(t: SCM) -> SCM;
    pub fn scm_join_thread_timed(t: SCM, timeout: SCM, timeoutval: SCM)
     -> SCM;
    pub fn scm_thread_p(t: SCM) -> SCM;
    pub fn scm_make_mutex() -> SCM;
    pub fn scm_make_recursive_mutex() -> SCM;
    pub fn scm_make_mutex_with_flags(flags: SCM) -> SCM;
    pub fn scm_lock_mutex(m: SCM) -> SCM;
    pub fn scm_lock_mutex_timed(m: SCM, timeout: SCM, owner: SCM) -> SCM;
    pub fn scm_dynwind_lock_mutex(mutex: SCM);
    pub fn scm_try_mutex(m: SCM) -> SCM;
    pub fn scm_unlock_mutex(m: SCM) -> SCM;
    pub fn scm_unlock_mutex_timed(m: SCM, cond: SCM, timeout: SCM) -> SCM;
    pub fn scm_mutex_p(o: SCM) -> SCM;
    pub fn scm_mutex_locked_p(m: SCM) -> SCM;
    pub fn scm_mutex_owner(m: SCM) -> SCM;
    pub fn scm_mutex_level(m: SCM) -> SCM;
    pub fn scm_make_condition_variable() -> SCM;
    pub fn scm_wait_condition_variable(cond: SCM, mutex: SCM) -> SCM;
    pub fn scm_timed_wait_condition_variable(cond: SCM, mutex: SCM,
                                             abstime: SCM) -> SCM;
    pub fn scm_signal_condition_variable(cond: SCM) -> SCM;
    pub fn scm_broadcast_condition_variable(cond: SCM) -> SCM;
    pub fn scm_condition_variable_p(o: SCM) -> SCM;
    pub fn scm_current_thread() -> SCM;
    pub fn scm_all_threads() -> SCM;
    pub fn scm_c_thread_exited_p(thread: SCM) -> c_int;
    pub fn scm_thread_exited_p(thread: SCM) -> SCM;
    pub fn scm_dynwind_critical_section(mutex: SCM);
    pub fn scm_pthread_mutex_lock(mutex: *mut pthread_mutex_t)
     -> c_int;
    pub fn scm_dynwind_pthread_mutex_lock(mutex: *mut pthread_mutex_t);
    pub fn scm_pthread_cond_wait(cond: *mut pthread_cond_t,
                                 mutex: *mut pthread_mutex_t)
     -> c_int;
    pub fn scm_pthread_cond_timedwait(cond: *mut pthread_cond_t,
                                      mutex: *mut pthread_mutex_t,
                                      abstime: *const scm_t_timespec)
     -> c_int;
    pub fn scm_std_sleep(arg1: c_uint)
     -> c_uint;
    pub fn scm_std_usleep(arg1: c_ulong)
     -> c_ulong;
    pub fn scm_total_processor_count() -> SCM;
    pub fn scm_current_processor_count() -> SCM;
    pub fn scm_async_click();
    pub fn scm_switch();
    pub fn scm_async(thunk: SCM) -> SCM;
    pub fn scm_async_mark(a: SCM) -> SCM;
    pub fn scm_system_async_mark(a: SCM) -> SCM;
    pub fn scm_system_async_mark_for_thread(a: SCM, thread: SCM) -> SCM;
    pub fn scm_i_queue_async_cell(cell: SCM, arg1: *mut scm_i_thread);
    pub fn scm_i_setup_sleep(arg1: *mut scm_i_thread, obj: SCM,
                             m: *mut pthread_mutex_t,
                             fd: c_int)
     -> c_int;
    pub fn scm_i_reset_sleep(arg1: *mut scm_i_thread);
    pub fn scm_run_asyncs(list_of_a: SCM) -> SCM;
    pub fn scm_noop(args: SCM) -> SCM;
    pub fn scm_call_with_blocked_asyncs(_proc: SCM) -> SCM;
    pub fn scm_call_with_unblocked_asyncs(_proc: SCM) -> SCM;
    pub fn scm_c_call_with_blocked_asyncs(p:
                                              ::std::option::Option<unsafe extern "C" fn(d:
                                                                                             *mut c_void)
                                                                        ->
                                                                            *mut c_void>,
                                          d: *mut c_void)
     -> *mut c_void;
    pub fn scm_c_call_with_unblocked_asyncs(p:
                                                ::std::option::Option<unsafe extern "C" fn(d:
                                                                                               *mut c_void)
                                                                          ->
                                                                              *mut c_void>,
                                            d: *mut c_void)
     -> *mut c_void;
    pub fn scm_dynwind_block_asyncs();
    pub fn scm_dynwind_unblock_asyncs();
    pub fn scm_critical_section_start();
    pub fn scm_critical_section_end();
    pub fn scm_init_async();
    pub fn scm_system_async(thunk: SCM) -> SCM;
    pub fn scm_unmask_signals() -> SCM;
    pub fn scm_mask_signals() -> SCM;
    pub fn scm_is_bool(arg1: SCM) -> c_int;
    pub fn scm_to_bool(x: SCM) -> c_int;
    pub fn scm_not(x: SCM) -> SCM;
    pub fn scm_boolean_p(obj: SCM) -> SCM;
    pub fn scm_init_boolean();
    pub fn scm_bitvector_p(vec: SCM) -> SCM;
    pub fn scm_bitvector(bits: SCM) -> SCM;
    pub fn scm_make_bitvector(len: SCM, fill: SCM) -> SCM;
    pub fn scm_bitvector_length(vec: SCM) -> SCM;
    pub fn scm_bitvector_ref(vec: SCM, idx: SCM) -> SCM;
    pub fn scm_bitvector_set_x(vec: SCM, idx: SCM, val: SCM) -> SCM;
    pub fn scm_list_to_bitvector(list: SCM) -> SCM;
    pub fn scm_bitvector_to_list(vec: SCM) -> SCM;
    pub fn scm_bitvector_fill_x(vec: SCM, val: SCM) -> SCM;
    pub fn scm_bit_count(item: SCM, seq: SCM) -> SCM;
    pub fn scm_bit_position(item: SCM, v: SCM, k: SCM) -> SCM;
    pub fn scm_bit_set_star_x(v: SCM, kv: SCM, obj: SCM) -> SCM;
    pub fn scm_bit_count_star(v: SCM, kv: SCM, obj: SCM) -> SCM;
    pub fn scm_bit_invert_x(v: SCM) -> SCM;
    pub fn scm_istr2bve(str: SCM) -> SCM;
    pub fn scm_is_bitvector(obj: SCM) -> c_int;
    pub fn scm_c_make_bitvector(len: size_t, fill: SCM) -> SCM;
    pub fn scm_c_bitvector_length(vec: SCM) -> size_t;
    pub fn scm_c_bitvector_ref(vec: SCM, idx: size_t) -> SCM;
    pub fn scm_c_bitvector_set_x(vec: SCM, idx: size_t, val: SCM);
    pub fn scm_array_handle_bit_elements(h: *mut scm_t_array_handle)
     -> *const scm_t_uint32;
    pub fn scm_array_handle_bit_writable_elements(h: *mut scm_t_array_handle)
     -> *mut scm_t_uint32;
    pub fn scm_array_handle_bit_elements_offset(h: *mut scm_t_array_handle)
     -> size_t;
    pub fn scm_bitvector_elements(vec: SCM, h: *mut scm_t_array_handle,
                                  offp: *mut size_t, lenp: *mut size_t,
                                  incp: *mut ssize_t) -> *const scm_t_uint32;
    pub fn scm_bitvector_writable_elements(vec: SCM,
                                           h: *mut scm_t_array_handle,
                                           offp: *mut size_t,
                                           lenp: *mut size_t,
                                           incp: *mut ssize_t)
     -> *mut scm_t_uint32;
    pub fn scm_i_print_bitvector(vec: SCM, port: SCM,
                                 pstate: *mut scm_print_state)
     -> c_int;
    pub fn scm_i_bitvector_equal_p(vec1: SCM, vec2: SCM) -> SCM;
    pub fn scm_init_bitvectors();
    pub fn scm_c_make_bytevector(arg1: size_t) -> SCM;
    pub fn scm_is_bytevector(arg1: SCM) -> c_int;
    pub fn scm_c_bytevector_length(arg1: SCM) -> size_t;
    pub fn scm_c_bytevector_ref(arg1: SCM, arg2: size_t) -> scm_t_uint8;
    pub fn scm_c_bytevector_set_x(arg1: SCM, arg2: size_t, arg3: scm_t_uint8);
    pub fn scm_make_bytevector(arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_native_endianness() -> SCM;
    pub fn scm_bytevector_p(arg1: SCM) -> SCM;
    pub fn scm_bytevector_length(arg1: SCM) -> SCM;
    pub fn scm_bytevector_eq_p(arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_bytevector_fill_x(arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_bytevector_copy_x(arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM,
                                 arg5: SCM) -> SCM;
    pub fn scm_bytevector_copy(arg1: SCM) -> SCM;
    pub fn scm_uniform_array_to_bytevector(arg1: SCM) -> SCM;
    pub fn scm_bytevector_to_u8_list(arg1: SCM) -> SCM;
    pub fn scm_u8_list_to_bytevector(arg1: SCM) -> SCM;
    pub fn scm_uint_list_to_bytevector(arg1: SCM, arg2: SCM, arg3: SCM)
     -> SCM;
    pub fn scm_bytevector_to_uint_list(arg1: SCM, arg2: SCM, arg3: SCM)
     -> SCM;
    pub fn scm_sint_list_to_bytevector(arg1: SCM, arg2: SCM, arg3: SCM)
     -> SCM;
    pub fn scm_bytevector_to_sint_list(arg1: SCM, arg2: SCM, arg3: SCM)
     -> SCM;
    pub fn scm_bytevector_u16_native_ref(arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_bytevector_s16_native_ref(arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_bytevector_u32_native_ref(arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_bytevector_s32_native_ref(arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_bytevector_u64_native_ref(arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_bytevector_s64_native_ref(arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_bytevector_u8_ref(arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_bytevector_s8_ref(arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_bytevector_uint_ref(arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM)
     -> SCM;
    pub fn scm_bytevector_sint_ref(arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM)
     -> SCM;
    pub fn scm_bytevector_u16_ref(arg1: SCM, arg2: SCM, arg3: SCM) -> SCM;
    pub fn scm_bytevector_s16_ref(arg1: SCM, arg2: SCM, arg3: SCM) -> SCM;
    pub fn scm_bytevector_u32_ref(arg1: SCM, arg2: SCM, arg3: SCM) -> SCM;
    pub fn scm_bytevector_s32_ref(arg1: SCM, arg2: SCM, arg3: SCM) -> SCM;
    pub fn scm_bytevector_u64_ref(arg1: SCM, arg2: SCM, arg3: SCM) -> SCM;
    pub fn scm_bytevector_s64_ref(arg1: SCM, arg2: SCM, arg3: SCM) -> SCM;
    pub fn scm_bytevector_u16_native_set_x(arg1: SCM, arg2: SCM, arg3: SCM)
     -> SCM;
    pub fn scm_bytevector_s16_native_set_x(arg1: SCM, arg2: SCM, arg3: SCM)
     -> SCM;
    pub fn scm_bytevector_u32_native_set_x(arg1: SCM, arg2: SCM, arg3: SCM)
     -> SCM;
    pub fn scm_bytevector_s32_native_set_x(arg1: SCM, arg2: SCM, arg3: SCM)
     -> SCM;
    pub fn scm_bytevector_u64_native_set_x(arg1: SCM, arg2: SCM, arg3: SCM)
     -> SCM;
    pub fn scm_bytevector_s64_native_set_x(arg1: SCM, arg2: SCM, arg3: SCM)
     -> SCM;
    pub fn scm_bytevector_u8_set_x(arg1: SCM, arg2: SCM, arg3: SCM) -> SCM;
    pub fn scm_bytevector_s8_set_x(arg1: SCM, arg2: SCM, arg3: SCM) -> SCM;
    pub fn scm_bytevector_uint_set_x(arg1: SCM, arg2: SCM, arg3: SCM,
                                     arg4: SCM, arg5: SCM) -> SCM;
    pub fn scm_bytevector_sint_set_x(arg1: SCM, arg2: SCM, arg3: SCM,
                                     arg4: SCM, arg5: SCM) -> SCM;
    pub fn scm_bytevector_u16_set_x(arg1: SCM, arg2: SCM, arg3: SCM,
                                    arg4: SCM) -> SCM;
    pub fn scm_bytevector_s16_set_x(arg1: SCM, arg2: SCM, arg3: SCM,
                                    arg4: SCM) -> SCM;
    pub fn scm_bytevector_u32_set_x(arg1: SCM, arg2: SCM, arg3: SCM,
                                    arg4: SCM) -> SCM;
    pub fn scm_bytevector_s32_set_x(arg1: SCM, arg2: SCM, arg3: SCM,
                                    arg4: SCM) -> SCM;
    pub fn scm_bytevector_u64_set_x(arg1: SCM, arg2: SCM, arg3: SCM,
                                    arg4: SCM) -> SCM;
    pub fn scm_bytevector_s64_set_x(arg1: SCM, arg2: SCM, arg3: SCM,
                                    arg4: SCM) -> SCM;
    pub fn scm_bytevector_ieee_single_ref(arg1: SCM, arg2: SCM, arg3: SCM)
     -> SCM;
    pub fn scm_bytevector_ieee_single_native_ref(arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_bytevector_ieee_single_set_x(arg1: SCM, arg2: SCM, arg3: SCM,
                                            arg4: SCM) -> SCM;
    pub fn scm_bytevector_ieee_single_native_set_x(arg1: SCM, arg2: SCM,
                                                   arg3: SCM) -> SCM;
    pub fn scm_bytevector_ieee_double_ref(arg1: SCM, arg2: SCM, arg3: SCM)
     -> SCM;
    pub fn scm_bytevector_ieee_double_native_ref(arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_bytevector_ieee_double_set_x(arg1: SCM, arg2: SCM, arg3: SCM,
                                            arg4: SCM) -> SCM;
    pub fn scm_bytevector_ieee_double_native_set_x(arg1: SCM, arg2: SCM,
                                                   arg3: SCM) -> SCM;
    pub fn scm_string_to_utf8(arg1: SCM) -> SCM;
    pub fn scm_string_to_utf16(arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_string_to_utf32(arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_utf8_to_string(arg1: SCM) -> SCM;
    pub fn scm_utf16_to_string(arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_utf32_to_string(arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_i_make_typed_bytevector(arg1: size_t,
                                       arg2: scm_t_array_element_type) -> SCM;
    pub fn scm_c_take_typed_bytevector(arg1: *mut c_char,
                                       arg2: size_t,
                                       arg3: scm_t_array_element_type) -> SCM;
    pub fn scm_bootstrap_bytevectors();
    pub fn scm_init_bytevectors();
    pub fn scm_c_take_gc_bytevector(arg1: *mut c_char,
                                    arg2: size_t) -> SCM;
    pub fn scm_i_print_bytevector(arg1: SCM, arg2: SCM,
                                  arg3: *mut scm_print_state)
     -> c_int;
    pub fn scm_c_shrink_bytevector(arg1: SCM, arg2: size_t) -> SCM;
    pub fn scm_i_bytevector_generalized_set_x(arg1: SCM, arg2: size_t,
                                              arg3: SCM);
    pub fn scm_dynamic_link(fname: SCM) -> SCM;
    pub fn scm_dynamic_unlink(dobj: SCM) -> SCM;
    pub fn scm_dynamic_object_p(obj: SCM) -> SCM;
    pub fn scm_dynamic_pointer(name: SCM, dobj: SCM) -> SCM;
    pub fn scm_dynamic_func(symb: SCM, dobj: SCM) -> SCM;
    pub fn scm_dynamic_call(symb: SCM, dobj: SCM) -> SCM;
    pub fn scm_init_dynamic_linking();
    pub fn scm_eq_p(x: SCM, y: SCM) -> SCM;
    pub fn scm_eqv_p(x: SCM, y: SCM) -> SCM;
    pub fn scm_equal_p(x: SCM, y: SCM) -> SCM;
    pub fn scm_init_eq();
    pub fn scm_make_struct_layout(fields: SCM) -> SCM;
    pub fn scm_struct_p(x: SCM) -> SCM;
    pub fn scm_struct_vtable_p(x: SCM) -> SCM;
    pub fn scm_make_struct(vtable: SCM, tail_array_size: SCM, init: SCM)
     -> SCM;
    pub fn scm_c_make_struct(vtable: SCM, n_tail: size_t, n_inits: size_t,
                             init: scm_t_bits, ...) -> SCM;
    pub fn scm_c_make_structv(vtable: SCM, n_tail: size_t, n_inits: size_t,
                              init: *mut scm_t_bits) -> SCM;
    pub fn scm_make_vtable(fields: SCM, printer: SCM) -> SCM;
    pub fn scm_i_make_vtable_vtable(extra_fields: SCM) -> SCM;
    pub fn scm_make_vtable_vtable(extra_fields: SCM, tail_array_size: SCM,
                                  init: SCM) -> SCM;
    pub fn scm_struct_ref(handle: SCM, pos: SCM) -> SCM;
    pub fn scm_struct_set_x(handle: SCM, pos: SCM, val: SCM) -> SCM;
    pub fn scm_struct_vtable(handle: SCM) -> SCM;
    pub fn scm_struct_vtable_name(vtable: SCM) -> SCM;
    pub fn scm_set_struct_vtable_name_x(vtable: SCM, name: SCM) -> SCM;
    pub fn scm_print_struct(exp: SCM, port: SCM, arg1: *mut scm_print_state);
    pub fn scm_i_struct_equalp(s1: SCM, s2: SCM) -> SCM;
    pub fn scm_struct_ihashq(arg1: SCM, arg2: c_ulong,
                             arg3: *mut c_void)
     -> c_ulong;
    pub fn scm_i_struct_hash(s: SCM, n: c_ulong,
                             depth: size_t) -> c_ulong;
    pub fn scm_i_alloc_struct(vtable_data: *mut scm_t_bits,
                              n_words: c_int) -> SCM;
    pub fn scm_i_struct_inherit_vtable_magic(vtable: SCM, obj: SCM);
    pub fn scm_init_struct();
    pub fn scm_memoize_expression(exp: SCM) -> SCM;
    pub fn scm_unmemoize_expression(memoized: SCM) -> SCM;
    pub fn scm_memoized_expression_typecode(memoized: SCM) -> SCM;
    pub fn scm_memoized_expression_data(memoized: SCM) -> SCM;
    pub fn scm_memoized_typecode(sym: SCM) -> SCM;
    pub fn scm_memoize_variable_access_x(memoized: SCM, module: SCM) -> SCM;
    pub fn scm_memoized_p(obj: SCM) -> SCM;
    pub fn scm_init_memoize();
    pub fn scm_call_0(_proc: SCM) -> SCM;
    pub fn scm_call_1(_proc: SCM, arg1: SCM) -> SCM;
    pub fn scm_call_2(_proc: SCM, arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_call_3(_proc: SCM, arg1: SCM, arg2: SCM, arg3: SCM) -> SCM;
    pub fn scm_call_4(_proc: SCM, arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM)
     -> SCM;
    pub fn scm_call_5(_proc: SCM, arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM,
                      arg5: SCM) -> SCM;
    pub fn scm_call_6(_proc: SCM, arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM,
                      arg5: SCM, arg6: SCM) -> SCM;
    pub fn scm_call_7(_proc: SCM, arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM,
                      arg5: SCM, arg6: SCM, arg7: SCM) -> SCM;
    pub fn scm_call_8(_proc: SCM, arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM,
                      arg5: SCM, arg6: SCM, arg7: SCM, arg8: SCM) -> SCM;
    pub fn scm_call_9(_proc: SCM, arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM,
                      arg5: SCM, arg6: SCM, arg7: SCM, arg8: SCM, arg9: SCM)
     -> SCM;
    pub fn scm_call_n(_proc: SCM, argv: *mut SCM, nargs: size_t) -> SCM;
    pub fn scm_call(_proc: SCM, ...) -> SCM;
    pub fn scm_apply_0(_proc: SCM, args: SCM) -> SCM;
    pub fn scm_apply_1(_proc: SCM, arg1: SCM, args: SCM) -> SCM;
    pub fn scm_apply_2(_proc: SCM, arg1: SCM, arg2: SCM, args: SCM) -> SCM;
    pub fn scm_apply_3(_proc: SCM, arg1: SCM, arg2: SCM, arg3: SCM, args: SCM)
     -> SCM;
    pub fn scm_nconc2last(lst: SCM) -> SCM;
    pub fn scm_apply(_proc: SCM, arg1: SCM, args: SCM) -> SCM;
    pub fn scm_map(_proc: SCM, arg1: SCM, args: SCM) -> SCM;
    pub fn scm_for_each(_proc: SCM, arg1: SCM, args: SCM) -> SCM;
    pub fn scm_primitive_eval(exp: SCM) -> SCM;
    pub fn scm_eval(exp: SCM, module: SCM) -> SCM;
    pub fn scm_init_eval();
    pub fn scm_defined_p(sym: SCM, env: SCM) -> SCM;
    pub fn scm_self_evaluating_p(obj: SCM) -> SCM;
    pub fn scm_init_evalext();
    pub fn scm_c_register_extension(lib: *const c_char,
                                    init: *const c_char,
                                    func:
                                        ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                                       *mut c_void)>,
                                    data: *mut c_void);
    pub fn scm_c_load_extension(lib: *const c_char,
                                init: *const c_char);
    pub fn scm_load_extension(lib: SCM, init: SCM) -> SCM;
    pub fn scm_init_extensions();
    pub fn scm_add_feature(str: *const c_char);
    pub fn scm_program_arguments() -> SCM;
    pub fn scm_set_program_arguments(argc: c_int,
                                     argv: *mut *mut c_char,
                                     first: *mut c_char);
    pub fn scm_set_program_arguments_scm(lst: SCM) -> SCM;
    pub fn scm_init_feature();
    pub fn scm_chown(object: SCM, owner: SCM, group: SCM) -> SCM;
    pub fn scm_chmod(object: SCM, mode: SCM) -> SCM;
    pub fn scm_umask(mode: SCM) -> SCM;
    pub fn scm_open_fdes(path: SCM, flags: SCM, mode: SCM) -> SCM;
    pub fn scm_open(path: SCM, flags: SCM, mode: SCM) -> SCM;
    pub fn scm_close(fd_or_port: SCM) -> SCM;
    pub fn scm_close_fdes(fd: SCM) -> SCM;
    pub fn scm_stat(object: SCM, exception_on_error: SCM) -> SCM;
    pub fn scm_link(oldpath: SCM, newpath: SCM) -> SCM;
    pub fn scm_rename(oldname: SCM, newname: SCM) -> SCM;
    pub fn scm_delete_file(str: SCM) -> SCM;
    pub fn scm_mkdir(path: SCM, mode: SCM) -> SCM;
    pub fn scm_rmdir(path: SCM) -> SCM;
    pub fn scm_directory_stream_p(obj: SCM) -> SCM;
    pub fn scm_opendir(dirname: SCM) -> SCM;
    pub fn scm_readdir(port: SCM) -> SCM;
    pub fn scm_rewinddir(port: SCM) -> SCM;
    pub fn scm_closedir(port: SCM) -> SCM;
    pub fn scm_chdir(str: SCM) -> SCM;
    pub fn scm_getcwd() -> SCM;
    pub fn scm_select(reads: SCM, writes: SCM, excepts: SCM, secs: SCM,
                      msecs: SCM) -> SCM;
    pub fn scm_fcntl(object: SCM, cmd: SCM, value: SCM) -> SCM;
    pub fn scm_fsync(object: SCM) -> SCM;
    pub fn scm_symlink(oldpath: SCM, newpath: SCM) -> SCM;
    pub fn scm_readlink(path: SCM) -> SCM;
    pub fn scm_lstat(str: SCM) -> SCM;
    pub fn scm_copy_file(oldfile: SCM, newfile: SCM) -> SCM;
    pub fn scm_dirname(filename: SCM) -> SCM;
    pub fn scm_basename(filename: SCM, suffix: SCM) -> SCM;
    pub fn scm_canonicalize_path(path: SCM) -> SCM;
    pub fn scm_sendfile(out: SCM, _in: SCM, count: SCM, offset: SCM) -> SCM;
    pub fn scm_i_relativize_path(path: SCM, in_path: SCM) -> SCM;
    pub fn scm_init_filesys();
    pub fn scm_i_set_finalizer(obj: *mut c_void,
                               arg1: scm_t_finalizer_proc,
                               data: *mut c_void);
    pub fn scm_i_add_finalizer(obj: *mut c_void,
                               arg1: scm_t_finalizer_proc,
                               data: *mut c_void);
    pub fn scm_i_add_resuscitator(obj: *mut c_void,
                                  arg1: scm_t_finalizer_proc,
                                  data: *mut c_void);
    pub fn scm_init_finalizers();
    pub fn scm_vector_p(x: SCM) -> SCM;
    pub fn scm_vector_length(v: SCM) -> SCM;
    pub fn scm_vector(l: SCM) -> SCM;
    pub fn scm_vector_ref(v: SCM, k: SCM) -> SCM;
    pub fn scm_vector_set_x(v: SCM, k: SCM, obj: SCM) -> SCM;
    pub fn scm_make_vector(k: SCM, fill: SCM) -> SCM;
    pub fn scm_vector_to_list(v: SCM) -> SCM;
    pub fn scm_vector_fill_x(v: SCM, fill_x: SCM) -> SCM;
    pub fn scm_vector_move_left_x(vec1: SCM, start1: SCM, end1: SCM,
                                  vec2: SCM, start2: SCM) -> SCM;
    pub fn scm_vector_move_right_x(vec1: SCM, start1: SCM, end1: SCM,
                                   vec2: SCM, start2: SCM) -> SCM;
    pub fn scm_vector_copy(vec: SCM) -> SCM;
    pub fn scm_is_vector(obj: SCM) -> c_int;
    pub fn scm_is_simple_vector(obj: SCM) -> c_int;
    pub fn scm_c_make_vector(len: size_t, fill: SCM) -> SCM;
    pub fn scm_c_vector_length(vec: SCM) -> size_t;
    pub fn scm_c_vector_ref(vec: SCM, k: size_t) -> SCM;
    pub fn scm_c_vector_set_x(vec: SCM, k: size_t, obj: SCM);
    pub fn scm_vector_elements(vec: SCM, h: *mut scm_t_array_handle,
                               lenp: *mut size_t, incp: *mut ssize_t)
     -> *const SCM;
    pub fn scm_vector_writable_elements(vec: SCM, h: *mut scm_t_array_handle,
                                        lenp: *mut size_t, incp: *mut ssize_t)
     -> *mut SCM;
    pub fn scm_i_vector_equal_p(x: SCM, y: SCM) -> SCM;
    pub fn scm_i_make_weak_vector(_type: scm_t_bits, size: SCM, fill: SCM)
     -> SCM;
    pub fn scm_i_make_weak_vector_from_list(_type: scm_t_bits, lst: SCM)
     -> SCM;
    pub fn scm_init_vectors();
    pub fn scm_make_fluid() -> SCM;
    pub fn scm_make_fluid_with_default(dflt: SCM) -> SCM;
    pub fn scm_make_unbound_fluid() -> SCM;
    pub fn scm_is_fluid(obj: SCM) -> c_int;
    pub fn scm_fluid_p(fl: SCM) -> SCM;
    pub fn scm_fluid_ref(fluid: SCM) -> SCM;
    pub fn scm_fluid_set_x(fluid: SCM, value: SCM) -> SCM;
    pub fn scm_fluid_unset_x(fluid: SCM) -> SCM;
    pub fn scm_fluid_bound_p(fluid: SCM) -> SCM;
    pub fn scm_i_make_with_fluids(n: size_t, fluids: *mut SCM, vals: *mut SCM)
     -> SCM;
    pub fn scm_i_swap_with_fluids(with_fluids: SCM, dynamic_state: SCM);
    pub fn scm_c_with_fluids(fluids: SCM, vals: SCM,
                             cproc:
                                 ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                                *mut c_void)
                                                           -> SCM>,
                             cdata: *mut c_void) -> SCM;
    pub fn scm_c_with_fluid(fluid: SCM, val: SCM,
                            cproc:
                                ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                               *mut c_void)
                                                          -> SCM>,
                            cdata: *mut c_void) -> SCM;
    pub fn scm_with_fluids(fluids: SCM, vals: SCM, thunk: SCM) -> SCM;
    pub fn scm_with_fluid(fluid: SCM, val: SCM, thunk: SCM) -> SCM;
    pub fn scm_dynwind_fluid(fluid: SCM, value: SCM);
    pub fn scm_make_dynamic_state(parent: SCM) -> SCM;
    pub fn scm_dynamic_state_p(obj: SCM) -> SCM;
    pub fn scm_is_dynamic_state(obj: SCM) -> c_int;
    pub fn scm_current_dynamic_state() -> SCM;
    pub fn scm_set_current_dynamic_state(state: SCM) -> SCM;
    pub fn scm_dynwind_current_dynamic_state(state: SCM);
    pub fn scm_c_with_dynamic_state(state: SCM,
                                    func:
                                        ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                                       *mut c_void)
                                                                  ->
                                                                      *mut c_void>,
                                    data: *mut c_void)
     -> *mut c_void;
    pub fn scm_with_dynamic_state(state: SCM, _proc: SCM) -> SCM;
    pub fn scm_i_make_initial_dynamic_state() -> SCM;
    pub fn scm_i_fluid_print(exp: SCM, port: SCM,
                             pstate: *mut scm_print_state);
    pub fn scm_i_dynamic_state_print(exp: SCM, port: SCM,
                                     pstate: *mut scm_print_state);
    pub fn scm_i_with_fluids_print(exp: SCM, port: SCM,
                                   pstate: *mut scm_print_state);
    pub fn scm_init_fluids();
    pub fn scm_to_pointer(pointer: SCM) -> *mut c_void;
    pub fn scm_from_pointer(arg1: *mut c_void,
                            arg2: scm_t_pointer_finalizer) -> SCM;
    pub fn scm_alignof(_type: SCM) -> SCM;
    pub fn scm_sizeof(_type: SCM) -> SCM;
    pub fn scm_pointer_address(pointer: SCM) -> SCM;
    pub fn scm_pointer_to_bytevector(pointer: SCM, _type: SCM, offset: SCM,
                                     len: SCM) -> SCM;
    pub fn scm_set_pointer_finalizer_x(pointer: SCM, finalizer: SCM) -> SCM;
    pub fn scm_bytevector_to_pointer(bv: SCM, offset: SCM) -> SCM;
    pub fn scm_pointer_p(obj: SCM) -> SCM;
    pub fn scm_make_pointer(address: SCM, finalizer: SCM) -> SCM;
    pub fn scm_i_pointer_print(pointer: SCM, port: SCM,
                               pstate: *mut scm_print_state);
    pub fn scm_dereference_pointer(pointer: SCM) -> SCM;
    pub fn scm_string_to_pointer(string: SCM, encoding: SCM) -> SCM;
    pub fn scm_pointer_to_string(pointer: SCM, length: SCM, encoding: SCM)
     -> SCM;
    pub fn scm_pointer_to_procedure(return_type: SCM, func_ptr: SCM,
                                    arg_types: SCM) -> SCM;
    pub fn scm_procedure_to_pointer(return_type: SCM, func_ptr: SCM,
                                    arg_types: SCM) -> SCM;
    pub fn scm_i_foreign_call(foreign: SCM, argv: *const SCM) -> SCM;
    pub fn scm_register_foreign();
    pub fn access(__name: *const c_char,
                  __type: c_int) -> c_int;
    pub fn faccessat(__fd: c_int,
                     __file: *const c_char,
                     __type: c_int,
                     __flag: c_int) -> c_int;
    pub fn lseek(__fd: c_int, __offset: __off_t,
                 __whence: c_int) -> __off_t;
    pub fn close(__fd: c_int) -> c_int;
    pub fn read(__fd: c_int,
                __buf: *mut c_void, __nbytes: size_t)
     -> ssize_t;
    pub fn write(__fd: c_int,
                 __buf: *const c_void, __n: size_t)
     -> ssize_t;
    pub fn pread(__fd: c_int,
                 __buf: *mut c_void, __nbytes: size_t,
                 __offset: __off_t) -> ssize_t;
    pub fn pwrite(__fd: c_int,
                  __buf: *const c_void, __n: size_t,
                  __offset: __off_t) -> ssize_t;
    pub fn pipe(__pipedes: *mut c_int)
     -> c_int;
    pub fn alarm(__seconds: c_uint) -> c_uint;
    pub fn sleep(__seconds: c_uint) -> c_uint;
    pub fn ualarm(__value: __useconds_t, __interval: __useconds_t)
     -> __useconds_t;
    pub fn usleep(__useconds: __useconds_t) -> c_int;
    pub fn pause() -> c_int;
    pub fn chown(__file: *const c_char, __owner: __uid_t,
                 __group: __gid_t) -> c_int;
    pub fn fchown(__fd: c_int, __owner: __uid_t,
                  __group: __gid_t) -> c_int;
    pub fn lchown(__file: *const c_char, __owner: __uid_t,
                  __group: __gid_t) -> c_int;
    pub fn fchownat(__fd: c_int,
                    __file: *const c_char, __owner: __uid_t,
                    __group: __gid_t, __flag: c_int)
     -> c_int;
    pub fn chdir(__path: *const c_char)
     -> c_int;
    pub fn fchdir(__fd: c_int) -> c_int;
    pub fn getcwd(__buf: *mut c_char, __size: size_t)
     -> *mut c_char;
    pub fn getwd(__buf: *mut c_char)
     -> *mut c_char;
    pub fn dup(__fd: c_int) -> c_int;
    pub fn dup2(__fd: c_int, __fd2: c_int)
     -> c_int;
    pub fn execve(__path: *const c_char,
                  __argv: *const *mut c_char,
                  __envp: *const *mut c_char)
     -> c_int;
    pub fn fexecve(__fd: c_int,
                   __argv: *const *mut c_char,
                   __envp: *const *mut c_char)
     -> c_int;
    pub fn execv(__path: *const c_char,
                 __argv: *const *mut c_char)
     -> c_int;
    pub fn execle(__path: *const c_char,
                  __arg: *const c_char, ...)
     -> c_int;
    pub fn execl(__path: *const c_char,
                 __arg: *const c_char, ...)
     -> c_int;
    pub fn execvp(__file: *const c_char,
                  __argv: *const *mut c_char)
     -> c_int;
    pub fn execlp(__file: *const c_char,
                  __arg: *const c_char, ...)
     -> c_int;
    pub fn nice(__inc: c_int) -> c_int;
    pub fn _exit(__status: c_int);
    pub fn pathconf(__path: *const c_char,
                    __name: c_int) -> c_long;
    pub fn fpathconf(__fd: c_int,
                     __name: c_int) -> c_long;
    pub fn sysconf(__name: c_int) -> c_long;
    pub fn confstr(__name: c_int,
                   __buf: *mut c_char, __len: size_t)
     -> size_t;
    pub fn getpid() -> __pid_t;
    pub fn getppid() -> __pid_t;
    pub fn getpgrp() -> __pid_t;
    pub fn __getpgid(__pid: __pid_t) -> __pid_t;
    pub fn getpgid(__pid: __pid_t) -> __pid_t;
    pub fn setpgid(__pid: __pid_t, __pgid: __pid_t) -> c_int;
    pub fn setpgrp() -> c_int;
    pub fn setsid() -> __pid_t;
    pub fn getsid(__pid: __pid_t) -> __pid_t;
    pub fn getuid() -> __uid_t;
    pub fn geteuid() -> __uid_t;
    pub fn getgid() -> __gid_t;
    pub fn getegid() -> __gid_t;
    pub fn getgroups(__size: c_int, __list: *mut __gid_t)
     -> c_int;
    pub fn setuid(__uid: __uid_t) -> c_int;
    pub fn setreuid(__ruid: __uid_t, __euid: __uid_t)
     -> c_int;
    pub fn seteuid(__uid: __uid_t) -> c_int;
    pub fn setgid(__gid: __gid_t) -> c_int;
    pub fn setregid(__rgid: __gid_t, __egid: __gid_t)
     -> c_int;
    pub fn setegid(__gid: __gid_t) -> c_int;
    pub fn fork() -> __pid_t;
    pub fn vfork() -> __pid_t;
    pub fn ttyname(__fd: c_int)
     -> *mut c_char;
    pub fn ttyname_r(__fd: c_int,
                     __buf: *mut c_char, __buflen: size_t)
     -> c_int;
    pub fn isatty(__fd: c_int) -> c_int;
    pub fn ttyslot() -> c_int;
    pub fn link(__from: *const c_char,
                __to: *const c_char) -> c_int;
    pub fn linkat(__fromfd: c_int,
                  __from: *const c_char,
                  __tofd: c_int,
                  __to: *const c_char,
                  __flags: c_int) -> c_int;
    pub fn symlink(__from: *const c_char,
                   __to: *const c_char)
     -> c_int;
    pub fn readlink(__path: *const c_char,
                    __buf: *mut c_char, __len: size_t)
     -> ssize_t;
    pub fn symlinkat(__from: *const c_char,
                     __tofd: c_int,
                     __to: *const c_char)
     -> c_int;
    pub fn readlinkat(__fd: c_int,
                      __path: *const c_char,
                      __buf: *mut c_char, __len: size_t)
     -> ssize_t;
    pub fn unlink(__name: *const c_char)
     -> c_int;
    pub fn unlinkat(__fd: c_int,
                    __name: *const c_char,
                    __flag: c_int) -> c_int;
    pub fn rmdir(__path: *const c_char)
     -> c_int;
    pub fn tcgetpgrp(__fd: c_int) -> __pid_t;
    pub fn tcsetpgrp(__fd: c_int, __pgrp_id: __pid_t)
     -> c_int;
    pub fn getlogin() -> *mut c_char;
    pub fn getlogin_r(__name: *mut c_char, __name_len: size_t)
     -> c_int;
    pub fn setlogin(__name: *const c_char)
     -> c_int;
    pub fn getopt(___argc: c_int,
                  ___argv: *const *mut c_char,
                  __shortopts: *const c_char)
     -> c_int;
    pub fn gethostname(__name: *mut c_char, __len: size_t)
     -> c_int;
    pub fn sethostname(__name: *const c_char, __len: size_t)
     -> c_int;
    pub fn sethostid(__id: c_long) -> c_int;
    pub fn getdomainname(__name: *mut c_char, __len: size_t)
     -> c_int;
    pub fn setdomainname(__name: *const c_char, __len: size_t)
     -> c_int;
    pub fn vhangup() -> c_int;
    pub fn revoke(__file: *const c_char)
     -> c_int;
    pub fn profil(__sample_buffer: *mut c_ushort,
                  __size: size_t, __offset: size_t,
                  __scale: c_uint) -> c_int;
    pub fn acct(__name: *const c_char)
     -> c_int;
    pub fn getusershell() -> *mut c_char;
    pub fn endusershell();
    pub fn setusershell();
    pub fn daemon(__nochdir: c_int,
                  __noclose: c_int) -> c_int;
    pub fn chroot(__path: *const c_char)
     -> c_int;
    pub fn getpass(__prompt: *const c_char)
     -> *mut c_char;
    pub fn fsync(__fd: c_int) -> c_int;
    pub fn gethostid() -> c_long;
    pub fn sync();
    pub fn getpagesize() -> c_int;
    pub fn getdtablesize() -> c_int;
    pub fn truncate(__file: *const c_char, __length: __off_t)
     -> c_int;
    pub fn ftruncate(__fd: c_int, __length: __off_t)
     -> c_int;
    pub fn brk(__addr: *mut c_void) -> c_int;
    pub fn sbrk(__delta: intptr_t) -> *mut c_void;
    pub fn syscall(__sysno: c_long, ...)
     -> c_long;
    pub fn lockf(__fd: c_int, __cmd: c_int,
                 __len: __off_t) -> c_int;
    pub fn fdatasync(__fildes: c_int)
     -> c_int;
    pub fn scm_string_p(x: SCM) -> SCM;
    pub fn scm_string(chrs: SCM) -> SCM;
    pub fn scm_make_string(k: SCM, chr: SCM) -> SCM;
    pub fn scm_string_length(str: SCM) -> SCM;
    pub fn scm_string_bytes_per_char(str: SCM) -> SCM;
    pub fn scm_string_ref(str: SCM, k: SCM) -> SCM;
    pub fn scm_string_set_x(str: SCM, k: SCM, chr: SCM) -> SCM;
    pub fn scm_substring(str: SCM, start: SCM, end: SCM) -> SCM;
    pub fn scm_substring_read_only(str: SCM, start: SCM, end: SCM) -> SCM;
    pub fn scm_substring_shared(str: SCM, start: SCM, end: SCM) -> SCM;
    pub fn scm_substring_copy(str: SCM, start: SCM, end: SCM) -> SCM;
    pub fn scm_string_append(args: SCM) -> SCM;
    pub fn scm_from_stringn(str: *const c_char, len: size_t,
                            encoding: *const c_char,
                            handler: scm_t_string_failed_conversion_handler)
     -> SCM;
    pub fn scm_c_make_string(len: size_t, chr: SCM) -> SCM;
    pub fn scm_c_string_length(str: SCM) -> size_t;
    pub fn scm_c_symbol_length(sym: SCM) -> size_t;
    pub fn scm_c_string_ref(str: SCM, pos: size_t) -> SCM;
    pub fn scm_c_string_set_x(str: SCM, pos: size_t, chr: SCM);
    pub fn scm_c_substring(str: SCM, start: size_t, end: size_t) -> SCM;
    pub fn scm_c_substring_read_only(str: SCM, start: size_t, end: size_t)
     -> SCM;
    pub fn scm_c_substring_shared(str: SCM, start: size_t, end: size_t)
     -> SCM;
    pub fn scm_c_substring_copy(str: SCM, start: size_t, end: size_t) -> SCM;
    pub fn scm_from_locale_string(str: *const c_char) -> SCM;
    pub fn scm_from_locale_stringn(str: *const c_char,
                                   len: size_t) -> SCM;
    pub fn scm_take_locale_string(str: *mut c_char) -> SCM;
    pub fn scm_take_locale_stringn(str: *mut c_char,
                                   len: size_t) -> SCM;
    pub fn scm_to_locale_string(str: SCM) -> *mut c_char;
    pub fn scm_to_locale_stringn(str: SCM, lenp: *mut size_t)
     -> *mut c_char;
    pub fn scm_from_latin1_string(str: *const c_char) -> SCM;
    pub fn scm_from_latin1_stringn(str: *const c_char,
                                   len: size_t) -> SCM;
    pub fn scm_to_latin1_string(str: SCM) -> *mut c_char;
    pub fn scm_to_latin1_stringn(str: SCM, lenp: *mut size_t)
     -> *mut c_char;
    pub fn scm_to_utf8_string(str: SCM) -> *mut c_char;
    pub fn scm_to_utf8_stringn(str: SCM, lenp: *mut size_t)
     -> *mut c_char;
    pub fn scm_from_utf8_string(str: *const c_char) -> SCM;
    pub fn scm_from_utf8_stringn(str: *const c_char,
                                 len: size_t) -> SCM;
    pub fn scm_to_utf32_string(str: SCM) -> *mut scm_t_wchar;
    pub fn scm_to_utf32_stringn(str: SCM, lenp: *mut size_t)
     -> *mut scm_t_wchar;
    pub fn scm_from_utf32_string(str: *const scm_t_wchar) -> SCM;
    pub fn scm_from_utf32_stringn(str: *const scm_t_wchar, len: size_t)
     -> SCM;
    pub fn scm_to_stringn(str: SCM, lenp: *mut size_t,
                          encoding: *const c_char,
                          handler: scm_t_string_failed_conversion_handler)
     -> *mut c_char;
    pub fn scm_to_locale_stringbuf(str: SCM, buf: *mut c_char,
                                   max_len: size_t) -> size_t;
    pub fn scm_string_normalize_nfd(str: SCM) -> SCM;
    pub fn scm_string_normalize_nfkd(str: SCM) -> SCM;
    pub fn scm_string_normalize_nfc(str: SCM) -> SCM;
    pub fn scm_string_normalize_nfkc(str: SCM) -> SCM;
    pub fn scm_makfromstrs(argc: c_int,
                           argv: *mut *mut c_char) -> SCM;
    pub fn scm_i_make_string(len: size_t,
                             datap: *mut *mut c_char,
                             read_only_p: c_int) -> SCM;
    pub fn scm_i_make_wide_string(len: size_t, datap: *mut *mut scm_t_wchar,
                                  read_only_p: c_int) -> SCM;
    pub fn scm_i_set_string_read_only_x(str: SCM) -> SCM;
    pub fn scm_i_substring(str: SCM, start: size_t, end: size_t) -> SCM;
    pub fn scm_i_substring_read_only(str: SCM, start: size_t, end: size_t)
     -> SCM;
    pub fn scm_i_substring_shared(str: SCM, start: size_t, end: size_t)
     -> SCM;
    pub fn scm_i_substring_copy(str: SCM, start: size_t, end: size_t) -> SCM;
    pub fn scm_i_string_length(str: SCM) -> size_t;
    pub fn scm_i_string_chars(str: SCM) -> *const c_char;
    pub fn scm_i_string_writable_chars(str: SCM)
     -> *mut c_char;
    pub fn scm_i_string_wide_chars(str: SCM) -> *const scm_t_wchar;
    pub fn scm_i_string_data(str: SCM) -> *const c_void;
    pub fn scm_i_string_start_writing(str: SCM) -> SCM;
    pub fn scm_i_string_stop_writing();
    pub fn scm_i_is_narrow_string(str: SCM) -> c_int;
    pub fn scm_i_string_ref(str: SCM, x: size_t) -> scm_t_wchar;
    pub fn scm_i_string_contains_char(str: SCM, c: c_char)
     -> c_int;
    pub fn scm_i_string_strcmp(sstr: SCM, start_x: size_t,
                               cstr: *const c_char)
     -> c_int;
    pub fn scm_i_string_set_x(str: SCM, p: size_t, chr: scm_t_wchar);
    pub fn scm_i_make_symbol(name: SCM, flags: scm_t_bits,
                             hash: c_ulong, props: SCM)
     -> SCM;
    pub fn scm_i_c_make_symbol(name: *const c_char,
                               len: size_t, flags: scm_t_bits,
                               hash: c_ulong, props: SCM)
     -> SCM;
    pub fn scm_i_symbol_chars(sym: SCM) -> *const c_char;
    pub fn scm_i_symbol_wide_chars(sym: SCM) -> *const scm_t_wchar;
    pub fn scm_i_symbol_length(sym: SCM) -> size_t;
    pub fn scm_i_is_narrow_symbol(str: SCM) -> c_int;
    pub fn scm_i_try_narrow_string(str: SCM) -> c_int;
    pub fn scm_i_symbol_substring(sym: SCM, start: size_t, end: size_t)
     -> SCM;
    pub fn scm_i_symbol_ref(sym: SCM, x: size_t) -> scm_t_wchar;
    pub fn scm_encoding_error(subr: *const c_char,
                              err: c_int,
                              message: *const c_char,
                              port: SCM, chr: SCM);
    pub fn scm_decoding_error(subr: *const c_char,
                              err: c_int,
                              message: *const c_char,
                              port: SCM);
    pub fn scm_i_allocate_string_pointers(list: SCM)
     -> *mut *mut c_char;
    pub fn scm_i_get_substring_spec(len: size_t, start: SCM,
                                    cstart: *mut size_t, end: SCM,
                                    cend: *mut size_t);
    pub fn scm_sys_string_dump(arg1: SCM) -> SCM;
    pub fn scm_sys_symbol_dump(arg1: SCM) -> SCM;
    pub fn scm_i_deprecated_stringp(obj: SCM) -> c_int;
    pub fn scm_i_deprecated_string_chars(str: SCM)
     -> *mut c_char;
    pub fn scm_i_deprecated_string_length(str: SCM) -> size_t;
    pub fn scm_init_strings();
    pub fn scm_markstream(ptr: SCM) -> SCM;
    pub fn scm_make_port_type(name: *mut c_char,
                              fill_input:
                                  ::std::option::Option<extern "C" fn(port:
                                                                          SCM)
                                                            ->
                                                                c_int>,
                              write:
                                  ::std::option::Option<unsafe extern "C" fn(port:
                                                                                 SCM,
                                                                             data:
                                                                                 *const c_void,
                                                                             size:
                                                                                 size_t)>)
     -> scm_t_bits;
    pub fn scm_set_port_mark(tc: scm_t_bits,
                             mark:
                                 ::std::option::Option<extern "C" fn(arg1:
                                                                         SCM)
                                                           -> SCM>);
    pub fn scm_set_port_free(tc: scm_t_bits,
                             free:
                                 ::std::option::Option<extern "C" fn(arg1:
                                                                         SCM)
                                                           -> size_t>);
    pub fn scm_set_port_print(tc: scm_t_bits,
                              print:
                                  ::std::option::Option<unsafe extern "C" fn(exp:
                                                                                 SCM,
                                                                             port:
                                                                                 SCM,
                                                                             pstate:
                                                                                 *mut scm_print_state)
                                                            ->
                                                                c_int>);
    pub fn scm_set_port_equalp(tc: scm_t_bits,
                               equalp:
                                   ::std::option::Option<extern "C" fn(arg1:
                                                                           SCM,
                                                                       arg2:
                                                                           SCM)
                                                             -> SCM>);
    pub fn scm_set_port_close(tc: scm_t_bits,
                              close:
                                  ::std::option::Option<extern "C" fn(arg1:
                                                                          SCM)
                                                            ->
                                                                c_int>);
    pub fn scm_set_port_flush(tc: scm_t_bits,
                              flush:
                                  ::std::option::Option<extern "C" fn(port:
                                                                          SCM)>);
    pub fn scm_set_port_end_input(tc: scm_t_bits,
                                  end_input:
                                      ::std::option::Option<extern "C" fn(port:
                                                                              SCM,
                                                                          offset:
                                                                              c_int)>);
    pub fn scm_set_port_seek(tc: scm_t_bits,
                             seek:
                                 ::std::option::Option<extern "C" fn(port:
                                                                         SCM,
                                                                     OFFSET:
                                                                         scm_t_off,
                                                                     WHENCE:
                                                                         c_int)
                                                           -> scm_t_off>);
    pub fn scm_set_port_truncate(tc: scm_t_bits,
                                 truncate:
                                     ::std::option::Option<extern "C" fn(port:
                                                                             SCM,
                                                                         length:
                                                                             scm_t_off)>);
    pub fn scm_set_port_input_waiting(tc: scm_t_bits,
                                      input_waiting:
                                          ::std::option::Option<extern "C" fn(arg1:
                                                                                  SCM)
                                                                    ->
                                                                        c_int>);
    pub fn scm_char_ready_p(port: SCM) -> SCM;
    pub fn scm_take_from_input_buffers(port: SCM,
                                       dest: *mut c_char,
                                       read_len: size_t) -> size_t;
    pub fn scm_drain_input(port: SCM) -> SCM;
    pub fn scm_current_input_port() -> SCM;
    pub fn scm_current_output_port() -> SCM;
    pub fn scm_current_error_port() -> SCM;
    pub fn scm_current_warning_port() -> SCM;
    pub fn scm_current_load_port() -> SCM;
    pub fn scm_set_current_input_port(port: SCM) -> SCM;
    pub fn scm_set_current_output_port(port: SCM) -> SCM;
    pub fn scm_set_current_error_port(port: SCM) -> SCM;
    pub fn scm_set_current_warning_port(port: SCM) -> SCM;
    pub fn scm_dynwind_current_input_port(port: SCM);
    pub fn scm_dynwind_current_output_port(port: SCM);
    pub fn scm_dynwind_current_error_port(port: SCM);
    pub fn scm_new_port_table_entry(tag: scm_t_bits) -> SCM;
    pub fn scm_grow_port_cbuf(port: SCM, requested: size_t);
    pub fn scm_pt_size() -> SCM;
    pub fn scm_pt_member(member: SCM) -> SCM;
    pub fn scm_port_non_buffer(pt: *mut scm_t_port);
    pub fn scm_revealed_count(port: SCM) -> c_int;
    pub fn scm_port_revealed(port: SCM) -> SCM;
    pub fn scm_set_port_revealed_x(port: SCM, rcount: SCM) -> SCM;
    pub fn scm_mode_bits(modes: *mut c_char)
     -> c_long;
    pub fn scm_port_mode(port: SCM) -> SCM;
    pub fn scm_close_input_port(port: SCM) -> SCM;
    pub fn scm_close_output_port(port: SCM) -> SCM;
    pub fn scm_close_port(port: SCM) -> SCM;
    pub fn scm_port_for_each(_proc: SCM) -> SCM;
    pub fn scm_c_port_for_each(_proc:
                                   ::std::option::Option<unsafe extern "C" fn(data:
                                                                                  *mut c_void,
                                                                              p:
                                                                                  SCM)>,
                               data: *mut c_void);
    pub fn scm_input_port_p(x: SCM) -> SCM;
    pub fn scm_output_port_p(x: SCM) -> SCM;
    pub fn scm_port_p(x: SCM) -> SCM;
    pub fn scm_port_closed_p(port: SCM) -> SCM;
    pub fn scm_eof_object_p(x: SCM) -> SCM;
    pub fn scm_force_output(port: SCM) -> SCM;
    pub fn scm_flush_all_ports() -> SCM;
    pub fn scm_read_char(port: SCM) -> SCM;
    pub fn scm_getc(port: SCM) -> scm_t_wchar;
    pub fn scm_c_read(port: SCM, buffer: *mut c_void,
                      size: size_t) -> size_t;
    pub fn scm_c_write(port: SCM, buffer: *const c_void,
                       size: size_t);
    pub fn scm_lfwrite(ptr: *const c_char, size: size_t,
                       port: SCM);
    pub fn scm_lfwrite_substr(str: SCM, start: size_t, end: size_t,
                              port: SCM);
    pub fn scm_flush(port: SCM);
    pub fn scm_end_input(port: SCM);
    pub fn scm_fill_input(port: SCM) -> c_int;
    pub fn scm_unget_bytes(buf: *const c_uchar, len: size_t,
                           port: SCM);
    pub fn scm_unget_byte(c: c_int, port: SCM);
    pub fn scm_ungetc(c: scm_t_wchar, port: SCM);
    pub fn scm_ungets(s: *const c_char,
                      n: c_int, port: SCM);
    pub fn scm_peek_char(port: SCM) -> SCM;
    pub fn scm_unread_char(cobj: SCM, port: SCM) -> SCM;
    pub fn scm_unread_string(str: SCM, port: SCM) -> SCM;
    pub fn scm_seek(object: SCM, offset: SCM, whence: SCM) -> SCM;
    pub fn scm_truncate_file(object: SCM, length: SCM) -> SCM;
    pub fn scm_port_line(port: SCM) -> SCM;
    pub fn scm_set_port_line_x(port: SCM, line: SCM) -> SCM;
    pub fn scm_port_column(port: SCM) -> SCM;
    pub fn scm_set_port_column_x(port: SCM, line: SCM) -> SCM;
    pub fn scm_port_filename(port: SCM) -> SCM;
    pub fn scm_set_port_filename_x(port: SCM, filename: SCM) -> SCM;
    pub fn scm_i_port_property(port: SCM, key: SCM) -> SCM;
    pub fn scm_i_set_port_property_x(port: SCM, key: SCM, value: SCM) -> SCM;
    pub fn scm_i_default_port_encoding() -> *const c_char;
    pub fn scm_i_set_default_port_encoding(arg1:
                                               *const c_char);
    pub fn scm_i_set_port_encoding_x(port: SCM,
                                     str: *const c_char);
    pub fn scm_port_encoding(port: SCM) -> SCM;
    pub fn scm_set_port_encoding_x(port: SCM, encoding: SCM) -> SCM;
    pub fn scm_i_default_port_conversion_handler()
     -> scm_t_string_failed_conversion_handler;
    pub fn scm_i_set_default_port_conversion_handler(arg1:
                                                         scm_t_string_failed_conversion_handler);
    pub fn scm_slow_get_byte_or_eof(port: SCM) -> c_int;
    pub fn scm_slow_peek_byte_or_eof(port: SCM) -> c_int;
    pub fn scm_port_conversion_strategy(port: SCM) -> SCM;
    pub fn scm_set_port_conversion_strategy_x(port: SCM, behavior: SCM)
     -> SCM;
    pub fn scm_port_print(exp: SCM, port: SCM, arg1: *mut scm_print_state)
     -> c_int;
    pub fn scm_print_port_mode(exp: SCM, port: SCM);
    pub fn scm_void_port(mode_str: *mut c_char) -> SCM;
    pub fn scm_sys_make_void_port(mode: SCM) -> SCM;
    pub fn scm_init_ports();
    pub fn scm_add_to_port_table(port: SCM) -> *mut scm_t_port;
    pub fn scm_i_mode_bits(modes: SCM) -> c_long;
    pub fn scm_i_dynwind_current_load_port(port: SCM);
    pub fn scm_setbuf0(port: SCM) -> SCM;
    pub fn scm_setvbuf(port: SCM, mode: SCM, size: SCM) -> SCM;
    pub fn scm_evict_ports(fd: c_int);
    pub fn scm_open_file_with_encoding(filename: SCM, modes: SCM,
                                       guess_encoding: SCM, encoding: SCM)
     -> SCM;
    pub fn scm_open_file(filename: SCM, modes: SCM) -> SCM;
    pub fn scm_fdes_to_port(fdes: c_int,
                            mode: *mut c_char, name: SCM)
     -> SCM;
    pub fn scm_file_port_p(obj: SCM) -> SCM;
    pub fn scm_init_fports_keywords();
    pub fn scm_init_fports();
    pub fn scm_i_fdes_to_port(fdes: c_int,
                              mode_bits: c_long, name: SCM)
     -> SCM;
    pub fn scm_c_hook_init(hook: *mut scm_t_c_hook,
                           hook_data: *mut c_void,
                           _type: scm_t_c_hook_type);
    pub fn scm_c_hook_add(hook: *mut scm_t_c_hook,
                          func: scm_t_c_hook_function,
                          fn_data: *mut c_void,
                          appendp: c_int);
    pub fn scm_c_hook_remove(hook: *mut scm_t_c_hook,
                             func: scm_t_c_hook_function,
                             fn_data: *mut c_void);
    pub fn scm_c_hook_run(hook: *mut scm_t_c_hook,
                          data: *mut c_void)
     -> *mut c_void;
    pub fn scm_make_hook(n_args: SCM) -> SCM;
    pub fn scm_hook_p(x: SCM) -> SCM;
    pub fn scm_hook_empty_p(hook: SCM) -> SCM;
    pub fn scm_add_hook_x(hook: SCM, thunk: SCM, appendp: SCM) -> SCM;
    pub fn scm_remove_hook_x(hook: SCM, thunk: SCM) -> SCM;
    pub fn scm_reset_hook_x(hook: SCM) -> SCM;
    pub fn scm_run_hook(hook: SCM, args: SCM) -> SCM;
    pub fn scm_c_run_hook(hook: SCM, args: SCM);
    pub fn scm_c_run_hookn(hook: SCM, argv: *mut SCM, nargs: size_t);
    pub fn scm_hook_to_list(hook: SCM) -> SCM;
    pub fn scm_init_hooks();
    pub fn scm_set_debug_cell_accesses_x(flag: SCM) -> SCM;
    pub fn scm_object_address(obj: SCM) -> SCM;
    pub fn scm_gc_enable() -> SCM;
    pub fn scm_gc_disable() -> SCM;
    pub fn scm_gc_dump() -> SCM;
    pub fn scm_gc_stats() -> SCM;
    pub fn scm_gc() -> SCM;
    pub fn scm_i_gc(what: *const c_char);
    pub fn scm_gc_mark(p: SCM);
    pub fn scm_gc_sweep();
    pub fn scm_gc_register_allocation(size: size_t);
    pub fn scm_malloc(size: size_t) -> *mut c_void;
    pub fn scm_calloc(size: size_t) -> *mut c_void;
    pub fn scm_realloc(mem: *mut c_void, size: size_t)
     -> *mut c_void;
    pub fn scm_strdup(str: *const c_char)
     -> *mut c_char;
    pub fn scm_strndup(str: *const c_char, n: size_t)
     -> *mut c_char;
    pub fn scm_gc_register_collectable_memory(mem:
                                                  *mut c_void,
                                              size: size_t,
                                              what:
                                                  *const c_char);
    pub fn scm_gc_unregister_collectable_memory(mem:
                                                    *mut c_void,
                                                size: size_t,
                                                what:
                                                    *const c_char);
    pub fn scm_gc_malloc_pointerless(size: size_t,
                                     what: *const c_char)
     -> *mut c_void;
    pub fn scm_gc_calloc(size: size_t, what: *const c_char)
     -> *mut c_void;
    pub fn scm_gc_malloc(size: size_t, what: *const c_char)
     -> *mut c_void;
    pub fn scm_gc_realloc(mem: *mut c_void, old_size: size_t,
                          new_size: size_t,
                          what: *const c_char)
     -> *mut c_void;
    pub fn scm_gc_free(mem: *mut c_void, size: size_t,
                       what: *const c_char);
    pub fn scm_gc_strdup(str: *const c_char,
                         what: *const c_char)
     -> *mut c_char;
    pub fn scm_gc_strndup(str: *const c_char, n: size_t,
                          what: *const c_char)
     -> *mut c_char;
    pub fn scm_cell(car: scm_t_bits, cdr: scm_t_bits) -> SCM;
    pub fn scm_double_cell(car: scm_t_bits, cbr: scm_t_bits, ccr: scm_t_bits,
                           cdr: scm_t_bits) -> SCM;
    pub fn scm_words(car: scm_t_bits, n_words: scm_t_uint16) -> SCM;
    pub fn scm_remember_upto_here_1(obj: SCM);
    pub fn scm_remember_upto_here_2(obj1: SCM, obj2: SCM);
    pub fn scm_remember_upto_here(obj1: SCM, ...);
    pub fn scm_return_first(elt: SCM, ...) -> SCM;
    pub fn scm_return_first_int(x: c_int, ...)
     -> c_int;
    pub fn scm_permanent_object(obj: SCM) -> SCM;
    pub fn scm_gc_protect_object(obj: SCM) -> SCM;
    pub fn scm_gc_unprotect_object(obj: SCM) -> SCM;
    pub fn scm_gc_register_root(p: *mut SCM);
    pub fn scm_gc_unregister_root(p: *mut SCM);
    pub fn scm_gc_register_roots(b: *mut SCM, n: c_ulong);
    pub fn scm_gc_unregister_roots(b: *mut SCM, n: c_ulong);
    pub fn scm_storage_prehistory();
    pub fn scm_init_gc_protect_object();
    pub fn scm_init_gc();
    pub fn scm_deprecated_newcell() -> SCM;
    pub fn scm_deprecated_newcell2() -> SCM;
    pub fn scm_must_malloc(len: size_t, what: *const c_char)
     -> *mut c_void;
    pub fn scm_must_realloc(_where: *mut c_void, olen: size_t,
                            len: size_t, what: *const c_char)
     -> *mut c_void;
    pub fn scm_must_strdup(str: *const c_char)
     -> *mut c_char;
    pub fn scm_must_strndup(str: *const c_char, n: size_t)
     -> *mut c_char;
    pub fn scm_done_malloc(size: c_long);
    pub fn scm_done_free(size: c_long);
    pub fn scm_must_free(obj: *mut c_void);
    pub fn scm_init_gdbint();
    pub fn scm_is_array(obj: SCM) -> c_int;
    pub fn scm_array_p(v: SCM, unused: SCM) -> SCM;
    pub fn scm_array_p_2(arg1: SCM) -> SCM;
    pub fn scm_is_typed_array(obj: SCM, _type: SCM) -> c_int;
    pub fn scm_typed_array_p(v: SCM, _type: SCM) -> SCM;
    pub fn scm_c_array_rank(ra: SCM) -> size_t;
    pub fn scm_array_rank(ra: SCM) -> SCM;
    pub fn scm_c_array_length(ra: SCM) -> size_t;
    pub fn scm_array_length(ra: SCM) -> SCM;
    pub fn scm_array_dimensions(ra: SCM) -> SCM;
    pub fn scm_array_type(ra: SCM) -> SCM;
    pub fn scm_array_in_bounds_p(v: SCM, args: SCM) -> SCM;
    pub fn scm_c_array_ref_1(v: SCM, idx0: ssize_t) -> SCM;
    pub fn scm_c_array_ref_2(v: SCM, idx0: ssize_t, idx1: ssize_t) -> SCM;
    pub fn scm_c_array_set_1_x(v: SCM, obj: SCM, idx0: ssize_t);
    pub fn scm_c_array_set_2_x(v: SCM, obj: SCM, idx0: ssize_t,
                               idx1: ssize_t);
    pub fn scm_array_ref(v: SCM, args: SCM) -> SCM;
    pub fn scm_array_set_x(v: SCM, obj: SCM, args: SCM) -> SCM;
    pub fn scm_array_to_list(v: SCM) -> SCM;
    pub fn scm_init_generalized_arrays();
    pub fn scm_is_generalized_vector(obj: SCM) -> c_int;
    pub fn scm_c_generalized_vector_length(v: SCM) -> size_t;
    pub fn scm_c_generalized_vector_ref(v: SCM, idx: size_t) -> SCM;
    pub fn scm_c_generalized_vector_set_x(v: SCM, idx: size_t, val: SCM);
    pub fn scm_generalized_vector_get_handle(vec: SCM,
                                             h: *mut scm_t_array_handle);
    pub fn scm_make_generalized_vector(_type: SCM, len: SCM, fill: SCM)
     -> SCM;
    pub fn scm_i_register_vector_constructor(_type: SCM,
                                             ctor:
                                                 ::std::option::Option<extern "C" fn(arg1:
                                                                                         SCM,
                                                                                     arg2:
                                                                                         SCM)
                                                                           ->
                                                                               SCM>);
    pub fn scm_init_generalized_vectors();
    pub fn scm_goops_version() -> SCM;
    pub fn scm_oldfmt(arg1: SCM) -> SCM;
    pub fn scm_c_oldfmt0(arg1: *mut c_char)
     -> *mut c_char;
    pub fn scm_c_oldfmt(arg1: *mut c_char,
                        n: c_int)
     -> *mut c_char;
    pub fn scm_load_goops();
    pub fn scm_make_extended_class(type_name: *const c_char,
                                   applicablep: c_int) -> SCM;
    pub fn scm_make_port_classes(ptobnum: c_long,
                                 type_name: *mut c_char);
    pub fn scm_ensure_accessor(name: SCM) -> SCM;
    pub fn scm_class_of(obj: SCM) -> SCM;
    pub fn scm_make_next_method(methods: SCM, args: SCM, gf: SCM) -> SCM;
    pub fn scm_basic_basic_make_class(c: SCM, name: SCM, dsupers: SCM,
                                      dslots: SCM) -> SCM;
    pub fn scm_basic_make_class(c: SCM, name: SCM, dsupers: SCM, dslots: SCM)
     -> SCM;
    pub fn scm_sys_allocate_instance(c: SCM, initargs: SCM) -> SCM;
    pub fn scm_sys_set_object_setter_x(obj: SCM, setter: SCM) -> SCM;
    pub fn scm_slot_ref(obj: SCM, slot_name: SCM) -> SCM;
    pub fn scm_slot_set_x(obj: SCM, slot_name: SCM, value: SCM) -> SCM;
    pub fn scm_compute_applicable_methods(gf: SCM, args: SCM,
                                          len: c_long,
                                          scm_find_method:
                                              c_int) -> SCM;
    pub fn scm_sys_compute_applicable_methods(gf: SCM, args: SCM) -> SCM;
    pub fn scm_sys_compute_slots(c: SCM) -> SCM;
    pub fn scm_i_inherit_applicable(c: SCM);
    pub fn scm_i_get_keyword(key: SCM, l: SCM, len: c_long,
                             default_value: SCM,
                             subr: *const c_char) -> SCM;
    pub fn scm_get_keyword(key: SCM, l: SCM, default_value: SCM) -> SCM;
    pub fn scm_sys_initialize_object(obj: SCM, initargs: SCM) -> SCM;
    pub fn scm_sys_prep_layout_x(c: SCM) -> SCM;
    pub fn scm_sys_inherit_magic_x(c: SCM, dsupers: SCM) -> SCM;
    pub fn scm_instance_p(obj: SCM) -> SCM;
    pub fn scm_class_name(obj: SCM) -> SCM;
    pub fn scm_class_direct_supers(obj: SCM) -> SCM;
    pub fn scm_class_direct_slots(obj: SCM) -> SCM;
    pub fn scm_class_direct_subclasses(obj: SCM) -> SCM;
    pub fn scm_class_direct_methods(obj: SCM) -> SCM;
    pub fn scm_class_precedence_list(obj: SCM) -> SCM;
    pub fn scm_class_slots(obj: SCM) -> SCM;
    pub fn scm_generic_function_name(obj: SCM) -> SCM;
    pub fn scm_generic_function_methods(obj: SCM) -> SCM;
    pub fn scm_method_generic_function(obj: SCM) -> SCM;
    pub fn scm_method_specializers(obj: SCM) -> SCM;
    pub fn scm_method_procedure(obj: SCM) -> SCM;
    pub fn scm_sys_fast_slot_ref(obj: SCM, index: SCM) -> SCM;
    pub fn scm_sys_fast_slot_set_x(obj: SCM, index: SCM, value: SCM) -> SCM;
    pub fn scm_slot_ref_using_class(cls: SCM, obj: SCM, slot_name: SCM)
     -> SCM;
    pub fn scm_slot_set_using_class_x(cls: SCM, obj: SCM, slot_name: SCM,
                                      value: SCM) -> SCM;
    pub fn scm_slot_bound_using_class_p(cls: SCM, obj: SCM, slot_name: SCM)
     -> SCM;
    pub fn scm_slot_exists_using_class_p(cls: SCM, obj: SCM, slot_name: SCM)
     -> SCM;
    pub fn scm_slot_bound_p(obj: SCM, slot_name: SCM) -> SCM;
    pub fn scm_slot_exists_p(obj: SCM, slot_name: SCM) -> SCM;
    pub fn scm_sys_modify_instance(old: SCM, newinst: SCM) -> SCM;
    pub fn scm_sys_modify_class(old: SCM, newcls: SCM) -> SCM;
    pub fn scm_sys_invalidate_class(cls: SCM) -> SCM;
    pub fn scm_sys_invalidate_method_cache_x(gf: SCM) -> SCM;
    pub fn scm_generic_capability_p(_proc: SCM) -> SCM;
    pub fn scm_enable_primitive_generic_x(subrs: SCM) -> SCM;
    pub fn scm_set_primitive_generic_x(subr: SCM, generic: SCM) -> SCM;
    pub fn scm_primitive_generic_generic(subr: SCM) -> SCM;
    pub fn scm_c_extend_primitive_generic(subr: SCM, extension: SCM);
    pub fn stklos_version() -> SCM;
    pub fn scm_make(args: SCM) -> SCM;
    pub fn scm_find_method(args: SCM) -> SCM;
    pub fn scm_sys_method_more_specific_p(m1: SCM, m2: SCM, targs: SCM)
     -> SCM;
    pub fn scm_change_object_class(arg1: SCM, arg2: SCM, arg3: SCM);
    pub fn scm_call_generic_3(gf: SCM, a1: SCM, a2: SCM, a3: SCM) -> SCM;
    pub fn scm_i_define_class_for_vtable(vtable: SCM) -> SCM;
    pub fn scm_init_goops_builtins() -> SCM;
    pub fn scm_init_goops();
    pub fn scm_subr_objcode_trampoline(nreq: c_uint,
                                       nopt: c_uint,
                                       rest: c_uint) -> SCM;
    pub fn scm_c_make_gsubr(name: *const c_char,
                            req: c_int,
                            opt: c_int,
                            rst: c_int, fcn: scm_t_subr)
     -> SCM;
    pub fn scm_c_make_gsubr_with_generic(name: *const c_char,
                                         req: c_int,
                                         opt: c_int,
                                         rst: c_int,
                                         fcn: scm_t_subr, gf: *mut SCM)
     -> SCM;
    pub fn scm_c_define_gsubr(name: *const c_char,
                              req: c_int,
                              opt: c_int,
                              rst: c_int, fcn: scm_t_subr)
     -> SCM;
    pub fn scm_c_define_gsubr_with_generic(name:
                                               *const c_char,
                                           req: c_int,
                                           opt: c_int,
                                           rst: c_int,
                                           fcn: scm_t_subr, gf: *mut SCM)
     -> SCM;
    pub fn scm_init_gsubr();
    pub fn scm_make_guardian() -> SCM;
    pub fn scm_i_init_guardians_for_gc();
    pub fn scm_i_identify_inaccessible_guardeds();
    pub fn scm_i_mark_inaccessible_guardeds() -> c_int;
    pub fn scm_init_guardians();
    pub fn scm_string_hash(str: *const c_uchar, len: size_t)
     -> c_ulong;
    pub fn scm_i_locale_string_hash(str: *const c_char,
                                    len: size_t) -> c_ulong;
    pub fn scm_i_latin1_string_hash(str: *const c_char,
                                    len: size_t) -> c_ulong;
    pub fn scm_i_utf8_string_hash(str: *const c_char,
                                  len: size_t) -> c_ulong;
    pub fn scm_i_string_hash(str: SCM) -> c_ulong;
    pub fn scm_hasher(obj: SCM, n: c_ulong, d: size_t)
     -> c_ulong;
    pub fn scm_ihashq(obj: SCM, n: c_ulong)
     -> c_ulong;
    pub fn scm_hashq(obj: SCM, n: SCM) -> SCM;
    pub fn scm_ihashv(obj: SCM, n: c_ulong)
     -> c_ulong;
    pub fn scm_hashv(obj: SCM, n: SCM) -> SCM;
    pub fn scm_ihash(obj: SCM, n: c_ulong)
     -> c_ulong;
    pub fn scm_hash(obj: SCM, n: SCM) -> SCM;
    pub fn scm_init_hash();
    pub fn scm_weak_car_pair(car: SCM, cdr: SCM) -> SCM;
    pub fn scm_weak_cdr_pair(car: SCM, cdr: SCM) -> SCM;
    pub fn scm_doubly_weak_pair(car: SCM, cdr: SCM) -> SCM;
    pub fn scm_make_weak_vector(k: SCM, fill: SCM) -> SCM;
    pub fn scm_weak_vector(l: SCM) -> SCM;
    pub fn scm_weak_vector_p(x: SCM) -> SCM;
    pub fn scm_weak_vector_length(v: SCM) -> SCM;
    pub fn scm_weak_vector_ref(v: SCM, k: SCM) -> SCM;
    pub fn scm_weak_vector_set_x(v: SCM, k: SCM, x: SCM) -> SCM;
    pub fn scm_c_make_weak_vector(k: size_t, fill: SCM) -> SCM;
    pub fn scm_is_weak_vector(obj: SCM) -> c_int;
    pub fn scm_c_weak_vector_length(vec: SCM) -> size_t;
    pub fn scm_c_weak_vector_ref(v: SCM, k: size_t) -> SCM;
    pub fn scm_c_weak_vector_set_x(v: SCM, k: size_t, x: SCM);
    pub fn scm_make_weak_key_alist_vector(k: SCM) -> SCM;
    pub fn scm_make_weak_value_alist_vector(k: SCM) -> SCM;
    pub fn scm_make_doubly_weak_alist_vector(k: SCM) -> SCM;
    pub fn scm_weak_key_alist_vector_p(x: SCM) -> SCM;
    pub fn scm_weak_value_alist_vector_p(x: SCM) -> SCM;
    pub fn scm_doubly_weak_alist_vector_p(x: SCM) -> SCM;
    pub fn scm_init_weaks_builtins() -> SCM;
    pub fn scm_weaks_prehistory();
    pub fn scm_init_weaks();
    pub fn scm_i_init_weak_vectors_for_gc();
    pub fn scm_i_mark_weak_vector(w: SCM);
    pub fn scm_i_mark_weak_vectors_non_weaks() -> c_int;
    pub fn scm_i_remove_weaks_from_weak_vectors();
    pub fn scm_vector_to_hash_table(vector: SCM) -> SCM;
    pub fn scm_c_make_hash_table(k: c_ulong) -> SCM;
    pub fn scm_make_hash_table(n: SCM) -> SCM;
    pub fn scm_make_weak_key_hash_table(k: SCM) -> SCM;
    pub fn scm_make_weak_value_hash_table(k: SCM) -> SCM;
    pub fn scm_make_doubly_weak_hash_table(k: SCM) -> SCM;
    pub fn scm_hash_table_p(h: SCM) -> SCM;
    pub fn scm_weak_key_hash_table_p(h: SCM) -> SCM;
    pub fn scm_weak_value_hash_table_p(h: SCM) -> SCM;
    pub fn scm_doubly_weak_hash_table_p(h: SCM) -> SCM;
    pub fn scm_i_rehash(table: SCM, hash_fn: scm_t_hash_fn,
                        closure: *mut c_void,
                        func_name: *const c_char);
    pub fn scm_hash_fn_get_handle(table: SCM, obj: SCM,
                                  hash_fn: scm_t_hash_fn,
                                  assoc_fn: scm_t_assoc_fn,
                                  closure: *mut c_void)
     -> SCM;
    pub fn scm_hash_fn_get_handle_by_hash(table: SCM,
                                          raw_hash: c_ulong,
                                          predicate_fn:
                                              scm_t_hash_predicate_fn,
                                          closure:
                                              *mut c_void)
     -> SCM;
    pub fn scm_hash_fn_create_handle_x(table: SCM, obj: SCM, init: SCM,
                                       hash_fn: scm_t_hash_fn,
                                       assoc_fn: scm_t_assoc_fn,
                                       closure: *mut c_void)
     -> SCM;
    pub fn scm_hash_fn_ref(table: SCM, obj: SCM, dflt: SCM,
                           hash_fn: scm_t_hash_fn, assoc_fn: scm_t_assoc_fn,
                           closure: *mut c_void) -> SCM;
    pub fn scm_hash_fn_set_x(table: SCM, obj: SCM, val: SCM,
                             hash_fn: scm_t_hash_fn, assoc_fn: scm_t_assoc_fn,
                             closure: *mut c_void) -> SCM;
    pub fn scm_hash_fn_remove_x(table: SCM, obj: SCM, hash_fn: scm_t_hash_fn,
                                assoc_fn: scm_t_assoc_fn,
                                closure: *mut c_void) -> SCM;
    pub fn scm_internal_hash_fold(_fn: scm_t_hash_fold_fn,
                                  closure: *mut c_void,
                                  init: SCM, table: SCM) -> SCM;
    pub fn scm_internal_hash_for_each_handle(_fn: scm_t_hash_handle_fn,
                                             closure:
                                                 *mut c_void,
                                             table: SCM);
    pub fn scm_hash_clear_x(table: SCM) -> SCM;
    pub fn scm_hashq_get_handle(table: SCM, obj: SCM) -> SCM;
    pub fn scm_hashq_create_handle_x(table: SCM, obj: SCM, init: SCM) -> SCM;
    pub fn scm_hashq_ref(table: SCM, obj: SCM, dflt: SCM) -> SCM;
    pub fn scm_hashq_set_x(table: SCM, obj: SCM, val: SCM) -> SCM;
    pub fn scm_hashq_remove_x(table: SCM, obj: SCM) -> SCM;
    pub fn scm_hashv_get_handle(table: SCM, obj: SCM) -> SCM;
    pub fn scm_hashv_create_handle_x(table: SCM, obj: SCM, init: SCM) -> SCM;
    pub fn scm_hashv_ref(table: SCM, obj: SCM, dflt: SCM) -> SCM;
    pub fn scm_hashv_set_x(table: SCM, obj: SCM, val: SCM) -> SCM;
    pub fn scm_hashv_remove_x(table: SCM, obj: SCM) -> SCM;
    pub fn scm_hash_get_handle(table: SCM, obj: SCM) -> SCM;
    pub fn scm_hash_create_handle_x(table: SCM, obj: SCM, init: SCM) -> SCM;
    pub fn scm_hash_ref(table: SCM, obj: SCM, dflt: SCM) -> SCM;
    pub fn scm_hash_set_x(table: SCM, obj: SCM, val: SCM) -> SCM;
    pub fn scm_hash_remove_x(table: SCM, obj: SCM) -> SCM;
    pub fn scm_hashx_get_handle(hash: SCM, assoc: SCM, table: SCM, obj: SCM)
     -> SCM;
    pub fn scm_hashx_create_handle_x(hash: SCM, assoc: SCM, table: SCM,
                                     obj: SCM, init: SCM) -> SCM;
    pub fn scm_hashx_ref(hash: SCM, assoc: SCM, table: SCM, obj: SCM,
                         dflt: SCM) -> SCM;
    pub fn scm_hashx_set_x(hash: SCM, assoc: SCM, table: SCM, obj: SCM,
                           val: SCM) -> SCM;
    pub fn scm_hashx_remove_x(hash: SCM, assoc: SCM, table: SCM, obj: SCM)
     -> SCM;
    pub fn scm_hash_fold(_proc: SCM, init: SCM, hash: SCM) -> SCM;
    pub fn scm_hash_for_each(_proc: SCM, hash: SCM) -> SCM;
    pub fn scm_hash_for_each_handle(_proc: SCM, hash: SCM) -> SCM;
    pub fn scm_hash_map_to_list(_proc: SCM, hash: SCM) -> SCM;
    pub fn scm_hash_count(hash: SCM, pred: SCM) -> SCM;
    pub fn scm_i_hashtable_print(exp: SCM, port: SCM,
                                 pstate: *mut scm_print_state);
    pub fn scm_init_hashtab();
    pub fn scm_make_locale(category_mask: SCM, locale_name: SCM,
                           base_locale: SCM) -> SCM;
    pub fn scm_locale_p(obj: SCM) -> SCM;
    pub fn scm_string_locale_lt(s1: SCM, s2: SCM, locale: SCM) -> SCM;
    pub fn scm_string_locale_gt(s1: SCM, s2: SCM, locale: SCM) -> SCM;
    pub fn scm_string_locale_ci_lt(s1: SCM, s2: SCM, locale: SCM) -> SCM;
    pub fn scm_string_locale_ci_gt(s1: SCM, s2: SCM, locale: SCM) -> SCM;
    pub fn scm_string_locale_ci_eq(s1: SCM, s2: SCM, locale: SCM) -> SCM;
    pub fn scm_char_locale_lt(c1: SCM, c2: SCM, locale: SCM) -> SCM;
    pub fn scm_char_locale_gt(c1: SCM, c2: SCM, locale: SCM) -> SCM;
    pub fn scm_char_locale_ci_lt(c1: SCM, c2: SCM, locale: SCM) -> SCM;
    pub fn scm_char_locale_ci_gt(c1: SCM, c2: SCM, locale: SCM) -> SCM;
    pub fn scm_char_locale_ci_eq(c1: SCM, c2: SCM, locale: SCM) -> SCM;
    pub fn scm_char_locale_upcase(chr: SCM, locale: SCM) -> SCM;
    pub fn scm_char_locale_downcase(chr: SCM, locale: SCM) -> SCM;
    pub fn scm_char_locale_titlecase(chr: SCM, locale: SCM) -> SCM;
    pub fn scm_string_locale_upcase(chr: SCM, locale: SCM) -> SCM;
    pub fn scm_string_locale_downcase(chr: SCM, locale: SCM) -> SCM;
    pub fn scm_string_locale_titlecase(chr: SCM, locale: SCM) -> SCM;
    pub fn scm_locale_string_to_integer(str: SCM, base: SCM, locale: SCM)
     -> SCM;
    pub fn scm_locale_string_to_inexact(str: SCM, locale: SCM) -> SCM;
    pub fn scm_nl_langinfo(item: SCM, locale: SCM) -> SCM;
    pub fn scm_init_i18n();
    pub fn scm_bootstrap_i18n();
    pub fn scm_init_guile();
    pub fn scm_boot_guile(argc: c_int,
                          argv: *mut *mut c_char,
                          main_func:
                              ::std::option::Option<unsafe extern "C" fn(closure:
                                                                             *mut c_void,
                                                                         argc:
                                                                             c_int,
                                                                         argv:
                                                                             *mut *mut c_char)>,
                          closure: *mut c_void);
    pub fn scm_i_init_guile(base: *mut c_void);
    pub fn scm_load_startup_files();
    pub fn scm_ftell(object: SCM) -> SCM;
    pub fn scm_redirect_port(into_pt: SCM, from_pt: SCM) -> SCM;
    pub fn scm_dup_to_fdes(fd_or_port: SCM, newfd: SCM) -> SCM;
    pub fn scm_dup2(oldfd: SCM, newfd: SCM) -> SCM;
    pub fn scm_fileno(port: SCM) -> SCM;
    pub fn scm_isatty_p(port: SCM) -> SCM;
    pub fn scm_fdopen(fdes: SCM, modes: SCM) -> SCM;
    pub fn scm_primitive_move_to_fdes(port: SCM, fd: SCM) -> SCM;
    pub fn scm_fdes_to_ports(fd: SCM) -> SCM;
    pub fn scm_init_ioext();
    pub fn scm_read_delimited_x(delims: SCM, buf: SCM, gobble: SCM, port: SCM,
                                offset: SCM, length: SCM) -> SCM;
    pub fn scm_read_line(port: SCM) -> SCM;
    pub fn scm_write_line(obj: SCM, port: SCM) -> SCM;
    pub fn scm_init_rdelim_builtins() -> SCM;
    pub fn scm_init_rdelim();
    pub fn scm_read_string_x_partial(str: SCM, port_or_fdes: SCM, start: SCM,
                                     end: SCM) -> SCM;
    pub fn scm_write_string_partial(str: SCM, port_or_fdes: SCM, start: SCM,
                                    end: SCM) -> SCM;
    pub fn scm_init_rw_builtins() -> SCM;
    pub fn scm_init_rw();
    pub fn scm_keyword_p(obj: SCM) -> SCM;
    pub fn scm_symbol_to_keyword(symbol: SCM) -> SCM;
    pub fn scm_keyword_to_symbol(keyword: SCM) -> SCM;
    pub fn scm_is_keyword(val: SCM) -> c_int;
    pub fn scm_from_locale_keyword(name: *const c_char)
     -> SCM;
    pub fn scm_from_locale_keywordn(name: *const c_char,
                                    len: size_t) -> SCM;
    pub fn scm_from_latin1_keyword(name: *const c_char)
     -> SCM;
    pub fn scm_from_utf8_keyword(name: *const c_char) -> SCM;
    pub fn scm_c_bind_keyword_arguments(subr: *const c_char,
                                        rest: SCM,
                                        flags:
                                            scm_t_keyword_arguments_flags, ...);
    pub fn scm_init_keywords();
    pub fn scm_list_1(e1: SCM) -> SCM;
    pub fn scm_list_2(e1: SCM, e2: SCM) -> SCM;
    pub fn scm_list_3(e1: SCM, e2: SCM, e3: SCM) -> SCM;
    pub fn scm_list_4(e1: SCM, e2: SCM, e3: SCM, e4: SCM) -> SCM;
    pub fn scm_list_5(e1: SCM, e2: SCM, e3: SCM, e4: SCM, e5: SCM) -> SCM;
    pub fn scm_list_n(elt: SCM, ...) -> SCM;
    pub fn scm_list(objs: SCM) -> SCM;
    pub fn scm_list_head(lst: SCM, k: SCM) -> SCM;
    pub fn scm_make_list(n: SCM, init: SCM) -> SCM;
    pub fn scm_cons_star(arg: SCM, objs: SCM) -> SCM;
    pub fn scm_null_p(x: SCM) -> SCM;
    pub fn scm_list_p(x: SCM) -> SCM;
    pub fn scm_ilength(sx: SCM) -> c_long;
    pub fn scm_length(x: SCM) -> SCM;
    pub fn scm_append(args: SCM) -> SCM;
    pub fn scm_append_x(args: SCM) -> SCM;
    pub fn scm_reverse(lst: SCM) -> SCM;
    pub fn scm_reverse_x(lst: SCM, newtail: SCM) -> SCM;
    pub fn scm_list_ref(lst: SCM, k: SCM) -> SCM;
    pub fn scm_list_set_x(lst: SCM, k: SCM, val: SCM) -> SCM;
    pub fn scm_list_cdr_set_x(lst: SCM, k: SCM, val: SCM) -> SCM;
    pub fn scm_last_pair(sx: SCM) -> SCM;
    pub fn scm_list_tail(lst: SCM, k: SCM) -> SCM;
    pub fn scm_c_memq(x: SCM, lst: SCM) -> SCM;
    pub fn scm_memq(x: SCM, lst: SCM) -> SCM;
    pub fn scm_memv(x: SCM, lst: SCM) -> SCM;
    pub fn scm_member(x: SCM, lst: SCM) -> SCM;
    pub fn scm_delq_x(item: SCM, lst: SCM) -> SCM;
    pub fn scm_delv_x(item: SCM, lst: SCM) -> SCM;
    pub fn scm_delete_x(item: SCM, lst: SCM) -> SCM;
    pub fn scm_list_copy(lst: SCM) -> SCM;
    pub fn scm_delq(item: SCM, lst: SCM) -> SCM;
    pub fn scm_delv(item: SCM, lst: SCM) -> SCM;
    pub fn scm_delete(item: SCM, lst: SCM) -> SCM;
    pub fn scm_delq1_x(item: SCM, lst: SCM) -> SCM;
    pub fn scm_delv1_x(item: SCM, lst: SCM) -> SCM;
    pub fn scm_delete1_x(item: SCM, lst: SCM) -> SCM;
    pub fn scm_filter(pred: SCM, list: SCM) -> SCM;
    pub fn scm_filter_x(pred: SCM, list: SCM) -> SCM;
    pub fn scm_copy_tree(obj: SCM) -> SCM;
    pub fn scm_i_finite_list_copy(arg1: SCM) -> SCM;
    pub fn scm_init_list();
    pub fn scm_parse_path(path: SCM, tail: SCM) -> SCM;
    pub fn scm_parse_path_with_ellipsis(path: SCM, base: SCM) -> SCM;
    pub fn scm_primitive_load(filename: SCM) -> SCM;
    pub fn scm_c_primitive_load(filename: *const c_char)
     -> SCM;
    pub fn scm_sys_package_data_dir() -> SCM;
    pub fn scm_sys_library_dir() -> SCM;
    pub fn scm_sys_site_dir() -> SCM;
    pub fn scm_sys_global_site_dir() -> SCM;
    pub fn scm_sys_site_ccache_dir() -> SCM;
    pub fn scm_search_path(path: SCM, filename: SCM, rest: SCM) -> SCM;
    pub fn scm_sys_search_load_path(filename: SCM) -> SCM;
    pub fn scm_primitive_load_path(filename_and_exception_on_not_found: SCM)
     -> SCM;
    pub fn scm_c_primitive_load_path(filename: *const c_char)
     -> SCM;
    pub fn scm_sys_warn_auto_compilation_enabled() -> SCM;
    pub fn scm_init_load_path();
    pub fn scm_init_load();
    pub fn scm_init_load_should_auto_compile();
    pub fn scm_init_eval_in_scheme();
    pub fn scm_make_syntax_transformer(name_or_existing_definition: SCM,
                                       _type: SCM, binding: SCM) -> SCM;
    pub fn scm_macro_p(obj: SCM) -> SCM;
    pub fn scm_macro_type(m: SCM) -> SCM;
    pub fn scm_macro_name(m: SCM) -> SCM;
    pub fn scm_macro_binding(m: SCM) -> SCM;
    pub fn scm_macro_transformer(m: SCM) -> SCM;
    pub fn scm_i_make_primitive_macro(name: *const c_char,
                                      _fn: scm_t_macro_primitive) -> SCM;
    pub fn scm_i_macro_primitive(m: SCM) -> scm_t_macro_primitive;
    pub fn scm_init_macros();
    pub fn scm_malloc_obj(n: size_t) -> SCM;
    pub fn scm_init_mallocs();
    pub fn scm_current_module() -> SCM;
    pub fn scm_the_root_module() -> SCM;
    pub fn scm_interaction_environment() -> SCM;
    pub fn scm_set_current_module(module: SCM) -> SCM;
    pub fn scm_c_call_with_current_module(module: SCM,
                                          func:
                                              ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                                             *mut c_void)
                                                                        ->
                                                                            SCM>,
                                          data: *mut c_void)
     -> SCM;
    pub fn scm_dynwind_current_module(module: SCM);
    pub fn scm_module_variable(module: SCM, sym: SCM) -> SCM;
    pub fn scm_module_local_variable(module: SCM, sym: SCM) -> SCM;
    pub fn scm_module_ensure_local_variable(module: SCM, sym: SCM) -> SCM;
    pub fn scm_c_lookup(name: *const c_char) -> SCM;
    pub fn scm_c_define(name: *const c_char, val: SCM) -> SCM;
    pub fn scm_lookup(symbol: SCM) -> SCM;
    pub fn scm_define(symbol: SCM, val: SCM) -> SCM;
    pub fn scm_c_module_lookup(module: SCM,
                               name: *const c_char) -> SCM;
    pub fn scm_c_module_define(module: SCM,
                               name: *const c_char, val: SCM)
     -> SCM;
    pub fn scm_module_lookup(module: SCM, symbol: SCM) -> SCM;
    pub fn scm_module_define(module: SCM, symbol: SCM, val: SCM) -> SCM;
    pub fn scm_module_export(module: SCM, symbol_list: SCM) -> SCM;
    pub fn scm_module_reverse_lookup(module: SCM, variable: SCM) -> SCM;
    pub fn scm_public_variable(module_name: SCM, name: SCM) -> SCM;
    pub fn scm_private_variable(module_name: SCM, name: SCM) -> SCM;
    pub fn scm_c_public_variable(module_name: *const c_char,
                                 name: *const c_char) -> SCM;
    pub fn scm_c_private_variable(module_name: *const c_char,
                                  name: *const c_char) -> SCM;
    pub fn scm_public_lookup(module_name: SCM, name: SCM) -> SCM;
    pub fn scm_private_lookup(module_name: SCM, name: SCM) -> SCM;
    pub fn scm_c_public_lookup(module_name: *const c_char,
                               name: *const c_char) -> SCM;
    pub fn scm_c_private_lookup(module_name: *const c_char,
                                name: *const c_char) -> SCM;
    pub fn scm_public_ref(module_name: SCM, name: SCM) -> SCM;
    pub fn scm_private_ref(module_name: SCM, name: SCM) -> SCM;
    pub fn scm_c_public_ref(module_name: *const c_char,
                            name: *const c_char) -> SCM;
    pub fn scm_c_private_ref(module_name: *const c_char,
                             name: *const c_char) -> SCM;
    pub fn scm_c_resolve_module(name: *const c_char) -> SCM;
    pub fn scm_resolve_module(name: SCM) -> SCM;
    pub fn scm_c_define_module(name: *const c_char,
                               init:
                                   ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                                  *mut c_void)>,
                               data: *mut c_void) -> SCM;
    pub fn scm_c_use_module(name: *const c_char);
    pub fn scm_c_export(name: *const c_char, ...);
    pub fn scm_module_public_interface(module: SCM) -> SCM;
    pub fn scm_module_import_interface(module: SCM, sym: SCM) -> SCM;
    pub fn scm_module_transformer(module: SCM) -> SCM;
    pub fn scm_current_module_transformer() -> SCM;
    pub fn scm_get_pre_modules_obarray() -> SCM;
    pub fn scm_modules_prehistory();
    pub fn scm_init_modules();
    pub fn scm_gethost(host: SCM) -> SCM;
    pub fn scm_getnet(name: SCM) -> SCM;
    pub fn scm_getproto(name: SCM) -> SCM;
    pub fn scm_getserv(name: SCM, proto: SCM) -> SCM;
    pub fn scm_sethost(arg: SCM) -> SCM;
    pub fn scm_setnet(arg: SCM) -> SCM;
    pub fn scm_setproto(arg: SCM) -> SCM;
    pub fn scm_setserv(arg: SCM) -> SCM;
    pub fn scm_getaddrinfo(arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM,
                           arg5: SCM, arg6: SCM) -> SCM;
    pub fn scm_gai_strerror(arg1: SCM) -> SCM;
    pub fn scm_init_net_db();
    pub fn scm_object_properties(obj: SCM) -> SCM;
    pub fn scm_set_object_properties_x(obj: SCM, plist: SCM) -> SCM;
    pub fn scm_object_property(obj: SCM, key: SCM) -> SCM;
    pub fn scm_set_object_property_x(obj: SCM, key: SCM, val: SCM) -> SCM;
    pub fn scm_init_objprop();
    pub fn scm_cons(x: SCM, y: SCM) -> SCM;
    pub fn scm_cons2(w: SCM, x: SCM, y: SCM) -> SCM;
    pub fn scm_pair_p(x: SCM) -> SCM;
    pub fn scm_car(x: SCM) -> SCM;
    pub fn scm_cdr(x: SCM) -> SCM;
    pub fn scm_set_car_x(pair: SCM, value: SCM) -> SCM;
    pub fn scm_set_cdr_x(pair: SCM, value: SCM) -> SCM;
    pub fn scm_cddr(x: SCM) -> SCM;
    pub fn scm_cdar(x: SCM) -> SCM;
    pub fn scm_cadr(x: SCM) -> SCM;
    pub fn scm_caar(x: SCM) -> SCM;
    pub fn scm_cdddr(x: SCM) -> SCM;
    pub fn scm_cddar(x: SCM) -> SCM;
    pub fn scm_cdadr(x: SCM) -> SCM;
    pub fn scm_cdaar(x: SCM) -> SCM;
    pub fn scm_caddr(x: SCM) -> SCM;
    pub fn scm_cadar(x: SCM) -> SCM;
    pub fn scm_caadr(x: SCM) -> SCM;
    pub fn scm_caaar(x: SCM) -> SCM;
    pub fn scm_cddddr(x: SCM) -> SCM;
    pub fn scm_cdddar(x: SCM) -> SCM;
    pub fn scm_cddadr(x: SCM) -> SCM;
    pub fn scm_cddaar(x: SCM) -> SCM;
    pub fn scm_cdaddr(x: SCM) -> SCM;
    pub fn scm_cdadar(x: SCM) -> SCM;
    pub fn scm_cdaadr(x: SCM) -> SCM;
    pub fn scm_cdaaar(x: SCM) -> SCM;
    pub fn scm_cadddr(x: SCM) -> SCM;
    pub fn scm_caddar(x: SCM) -> SCM;
    pub fn scm_cadadr(x: SCM) -> SCM;
    pub fn scm_cadaar(x: SCM) -> SCM;
    pub fn scm_caaddr(x: SCM) -> SCM;
    pub fn scm_caadar(x: SCM) -> SCM;
    pub fn scm_caaadr(x: SCM) -> SCM;
    pub fn scm_caaaar(x: SCM) -> SCM;
    pub fn scm_init_pairs();
    pub fn scm_tcsetpgrp(port: SCM, pgid: SCM) -> SCM;
    pub fn scm_tcgetpgrp(port: SCM) -> SCM;
    pub fn scm_ctermid() -> SCM;
    pub fn scm_setsid() -> SCM;
    pub fn scm_getsid(pid: SCM) -> SCM;
    pub fn scm_setpgid(pid: SCM, pgid: SCM) -> SCM;
    pub fn scm_pipe() -> SCM;
    pub fn scm_getgroups() -> SCM;
    pub fn scm_setgroups(groups: SCM) -> SCM;
    pub fn scm_getpgrp() -> SCM;
    pub fn scm_getpwuid(user: SCM) -> SCM;
    pub fn scm_setpwent(arg: SCM) -> SCM;
    pub fn scm_getgrgid(name: SCM) -> SCM;
    pub fn scm_setgrent(arg: SCM) -> SCM;
    pub fn scm_getrlimit(resource: SCM) -> SCM;
    pub fn scm_setrlimit(resource: SCM, soft: SCM, hard: SCM) -> SCM;
    pub fn scm_kill(pid: SCM, sig: SCM) -> SCM;
    pub fn scm_waitpid(pid: SCM, options: SCM) -> SCM;
    pub fn scm_status_exit_val(status: SCM) -> SCM;
    pub fn scm_status_term_sig(status: SCM) -> SCM;
    pub fn scm_status_stop_sig(status: SCM) -> SCM;
    pub fn scm_getppid() -> SCM;
    pub fn scm_getuid() -> SCM;
    pub fn scm_getgid() -> SCM;
    pub fn scm_geteuid() -> SCM;
    pub fn scm_getegid() -> SCM;
    pub fn scm_setuid(uid: SCM) -> SCM;
    pub fn scm_setgid(gid: SCM) -> SCM;
    pub fn scm_seteuid(euid: SCM) -> SCM;
    pub fn scm_setegid(egid: SCM) -> SCM;
    pub fn scm_ttyname(port: SCM) -> SCM;
    pub fn scm_execl(filename: SCM, args: SCM) -> SCM;
    pub fn scm_execlp(filename: SCM, args: SCM) -> SCM;
    pub fn scm_execle(filename: SCM, env: SCM, args: SCM) -> SCM;
    pub fn scm_fork() -> SCM;
    pub fn scm_uname() -> SCM;
    pub fn scm_environ(env: SCM) -> SCM;
    pub fn scm_tmpnam() -> SCM;
    pub fn scm_mkstemp(tmpl: SCM) -> SCM;
    pub fn scm_tmpfile() -> SCM;
    pub fn scm_open_pipe(pipestr: SCM, modes: SCM) -> SCM;
    pub fn scm_close_pipe(port: SCM) -> SCM;
    pub fn scm_utime(pathname: SCM, actime: SCM, modtime: SCM, actimens: SCM,
                     modtimens: SCM, flags: SCM) -> SCM;
    pub fn scm_access(path: SCM, how: SCM) -> SCM;
    pub fn scm_getpid() -> SCM;
    pub fn scm_putenv(str: SCM) -> SCM;
    pub fn scm_setlocale(category: SCM, locale: SCM) -> SCM;
    pub fn scm_mknod(path: SCM, _type: SCM, perms: SCM, dev: SCM) -> SCM;
    pub fn scm_nice(incr: SCM) -> SCM;
    pub fn scm_sync() -> SCM;
    pub fn scm_crypt(key: SCM, salt: SCM) -> SCM;
    pub fn scm_chroot(path: SCM) -> SCM;
    pub fn scm_getlogin() -> SCM;
    pub fn scm_getpriority(which: SCM, who: SCM) -> SCM;
    pub fn scm_setpriority(which: SCM, who: SCM, prio: SCM) -> SCM;
    pub fn scm_getpass(prompt: SCM) -> SCM;
    pub fn scm_flock(file: SCM, operation: SCM) -> SCM;
    pub fn scm_sethostname(name: SCM) -> SCM;
    pub fn scm_gethostname() -> SCM;
    pub fn scm_getaffinity(pid: SCM) -> SCM;
    pub fn scm_setaffinity(pid: SCM, cpu_set: SCM) -> SCM;
    pub fn scm_init_posix();
    pub fn scm_i_procedure_arity(_proc: SCM, req: *mut c_int,
                                 opt: *mut c_int,
                                 rest: *mut c_int)
     -> c_int;
    pub fn scm_set_procedure_minimum_arity_x(_proc: SCM, req: SCM, opt: SCM,
                                             rest: SCM) -> SCM;
    pub fn scm_procedure_minimum_arity(_proc: SCM) -> SCM;
    pub fn scm_procedure_properties(_proc: SCM) -> SCM;
    pub fn scm_set_procedure_properties_x(_proc: SCM, alist: SCM) -> SCM;
    pub fn scm_procedure_property(_proc: SCM, key: SCM) -> SCM;
    pub fn scm_set_procedure_property_x(_proc: SCM, key: SCM, val: SCM)
     -> SCM;
    pub fn scm_init_procprop();
    pub fn scm_make_promise(thunk: SCM) -> SCM;
    pub fn scm_force(x: SCM) -> SCM;
    pub fn scm_promise_p(x: SCM) -> SCM;
    pub fn scm_init_promises();
    pub fn scm_eof_object() -> SCM;
    pub fn scm_open_bytevector_input_port(arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_make_custom_binary_input_port(arg1: SCM, arg2: SCM, arg3: SCM,
                                             arg4: SCM, arg5: SCM) -> SCM;
    pub fn scm_get_u8(arg1: SCM) -> SCM;
    pub fn scm_lookahead_u8(arg1: SCM) -> SCM;
    pub fn scm_get_bytevector_n(arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_get_bytevector_n_x(arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM)
     -> SCM;
    pub fn scm_get_bytevector_some(arg1: SCM) -> SCM;
    pub fn scm_get_bytevector_all(arg1: SCM) -> SCM;
    pub fn scm_put_u8(arg1: SCM, arg2: SCM) -> SCM;
    pub fn scm_put_bytevector(arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM)
     -> SCM;
    pub fn scm_open_bytevector_output_port(arg1: SCM) -> SCM;
    pub fn scm_make_custom_binary_output_port(arg1: SCM, arg2: SCM, arg3: SCM,
                                              arg4: SCM, arg5: SCM) -> SCM;
    pub fn scm_get_string_n_x(arg1: SCM, arg2: SCM, arg3: SCM, arg4: SCM)
     -> SCM;
    pub fn scm_init_r6rs_ports();
    pub fn scm_register_r6rs_ports();
    pub fn scm_c_make_rstate(arg1: *const c_char,
                             arg2: c_int)
     -> *mut scm_t_rstate;
    pub fn scm_c_rstate_from_datum(datum: SCM) -> *mut scm_t_rstate;
    pub fn scm_c_default_rstate() -> *mut scm_t_rstate;
    pub fn scm_c_uniform01(arg1: *mut scm_t_rstate)
     -> c_double;
    pub fn scm_c_normal01(arg1: *mut scm_t_rstate)
     -> c_double;
    pub fn scm_c_exp1(arg1: *mut scm_t_rstate) -> c_double;
    pub fn scm_c_random(arg1: *mut scm_t_rstate, m: scm_t_uint32)
     -> scm_t_uint32;
    pub fn scm_c_random64(state: *mut scm_t_rstate, m: scm_t_uint64)
     -> scm_t_uint64;
    pub fn scm_c_random_bignum(arg1: *mut scm_t_rstate, m: SCM) -> SCM;
    pub fn scm_random(n: SCM, state: SCM) -> SCM;
    pub fn scm_copy_random_state(state: SCM) -> SCM;
    pub fn scm_seed_to_random_state(seed: SCM) -> SCM;
    pub fn scm_datum_to_random_state(datum: SCM) -> SCM;
    pub fn scm_random_state_to_datum(state: SCM) -> SCM;
    pub fn scm_random_state_from_platform() -> SCM;
    pub fn scm_random_uniform(state: SCM) -> SCM;
    pub fn scm_random_solid_sphere_x(v: SCM, state: SCM) -> SCM;
    pub fn scm_random_hollow_sphere_x(v: SCM, state: SCM) -> SCM;
    pub fn scm_random_normal(state: SCM) -> SCM;
    pub fn scm_random_normal_vector_x(v: SCM, state: SCM) -> SCM;
    pub fn scm_random_exp(state: SCM) -> SCM;
    pub fn scm_init_random();
    pub fn scm_i_random_bytes_from_platform(buf: *mut c_uchar,
                                            len: size_t);
    pub fn scm_read_options(setting: SCM) -> SCM;
    pub fn scm_read(port: SCM) -> SCM;
    pub fn scm_read_hash_extend(chr: SCM, _proc: SCM) -> SCM;
    pub fn scm_i_scan_for_encoding(port: SCM) -> *mut c_char;
    pub fn scm_file_encoding(port: SCM) -> SCM;
    pub fn scm_i_input_error(func: *const c_char, port: SCM,
                             message: *const c_char,
                             arg: SCM);
    pub fn scm_init_read();
    pub fn scm_sigaction(signum: SCM, handler: SCM, flags: SCM) -> SCM;
    pub fn scm_sigaction_for_thread(signum: SCM, handler: SCM, flags: SCM,
                                    thread: SCM) -> SCM;
    pub fn scm_restore_signals() -> SCM;
    pub fn scm_alarm(i: SCM) -> SCM;
    pub fn scm_setitimer(which_timer: SCM, interval_seconds: SCM,
                         interval_microseconds: SCM, value_seconds: SCM,
                         value_microseconds: SCM) -> SCM;
    pub fn scm_getitimer(which_timer: SCM) -> SCM;
    pub fn scm_pause() -> SCM;
    pub fn scm_sleep(i: SCM) -> SCM;
    pub fn scm_usleep(i: SCM) -> SCM;
    pub fn scm_raise(sig: SCM) -> SCM;
    pub fn scm_init_scmsigs();
    pub fn scm_i_close_signal_pipe();
    pub fn scm_i_ensure_signal_delivery_thread();
    pub fn scm_find_executable(name: *const c_char)
     -> *mut c_char;
    pub fn scm_find_impl_file(exec_path: *mut c_char,
                              generic_name: *const c_char,
                              initname: *const c_char,
                              sep: *const c_char)
     -> *mut c_char;
    pub fn scm_get_meta_args(argc: c_int,
                             argv: *mut *mut c_char)
     -> *mut *mut c_char;
    pub fn scm_count_argv(argv: *mut *mut c_char)
     -> c_int;
    pub fn scm_shell_usage(fatal: c_int,
                           message: *mut c_char);
    pub fn scm_compile_shell_switches(argc: c_int,
                                      argv: *mut *mut c_char)
     -> SCM;
    pub fn scm_shell(argc: c_int,
                     argv: *mut *mut c_char);
    pub fn scm_i_set_boot_program_arguments(argc: c_int,
                                            argv:
                                                *mut *mut c_char);
    pub fn scm_init_script();
    pub fn scm_system(cmd: SCM) -> SCM;
    pub fn scm_system_star(cmds: SCM) -> SCM;
    pub fn scm_getenv(nam: SCM) -> SCM;
    pub fn scm_primitive_exit(status: SCM) -> SCM;
    pub fn scm_primitive__exit(status: SCM) -> SCM;
    pub fn scm_init_simpos();
    pub fn scm_i_new_smob(tc: scm_t_bits, arg1: scm_t_bits) -> SCM;
    pub fn scm_i_new_double_smob(tc: scm_t_bits, arg1: scm_t_bits,
                                 arg2: scm_t_bits, arg3: scm_t_bits) -> SCM;
    pub fn scm_new_smob(tc: scm_t_bits, data: scm_t_bits) -> SCM;
    pub fn scm_new_double_smob(tc: scm_t_bits, data1: scm_t_bits,
                               data2: scm_t_bits, data3: scm_t_bits) -> SCM;
    pub fn scm_i_finalize_smob(ptr: *mut c_void,
                               data: *mut c_void);
    pub fn scm_i_new_smob_with_mark_proc(tc: scm_t_bits, arg1: scm_t_bits,
                                         arg2: scm_t_bits, arg3: scm_t_bits)
     -> SCM;
    pub fn scm_mark0(ptr: SCM) -> SCM;
    pub fn scm_markcdr(ptr: SCM) -> SCM;
    pub fn scm_free0(ptr: SCM) -> size_t;
    pub fn scm_smob_print(exp: SCM, port: SCM, pstate: *mut scm_print_state)
     -> c_int;
    pub fn scm_make_smob_type(name: *const c_char,
                              size: size_t) -> scm_t_bits;
    pub fn scm_set_smob_mark(tc: scm_t_bits,
                             mark:
                                 ::std::option::Option<extern "C" fn(arg1:
                                                                         SCM)
                                                           -> SCM>);
    pub fn scm_set_smob_free(tc: scm_t_bits,
                             free:
                                 ::std::option::Option<extern "C" fn(arg1:
                                                                         SCM)
                                                           -> size_t>);
    pub fn scm_set_smob_print(tc: scm_t_bits,
                              print:
                                  ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                                 SCM,
                                                                             arg2:
                                                                                 SCM,
                                                                             arg3:
                                                                                 *mut scm_print_state)
                                                            ->
                                                                c_int>);
    pub fn scm_set_smob_equalp(tc: scm_t_bits,
                               equalp:
                                   ::std::option::Option<extern "C" fn(arg1:
                                                                           SCM,
                                                                       arg2:
                                                                           SCM)
                                                             -> SCM>);
    pub fn scm_set_smob_apply(tc: scm_t_bits, apply: scm_t_subr,
                              req: c_uint,
                              opt: c_uint,
                              rst: c_uint);
    pub fn scm_assert_smob_type(tag: scm_t_bits, val: SCM);
    pub fn scm_make_smob(tc: scm_t_bits) -> SCM;
    pub fn scm_smob_prehistory();
    pub fn scm_inet_aton(address: SCM) -> SCM;
    pub fn scm_inet_ntoa(inetid: SCM) -> SCM;
    pub fn scm_inet_netof(address: SCM) -> SCM;
    pub fn scm_lnaof(address: SCM) -> SCM;
    pub fn scm_inet_makeaddr(net: SCM, lna: SCM) -> SCM;
    pub fn scm_inet_pton(family: SCM, address: SCM) -> SCM;
    pub fn scm_inet_ntop(family: SCM, address: SCM) -> SCM;
    pub fn scm_socket(family: SCM, style: SCM, proto: SCM) -> SCM;
    pub fn scm_socketpair(family: SCM, style: SCM, proto: SCM) -> SCM;
    pub fn scm_getsockopt(sfd: SCM, level: SCM, optname: SCM) -> SCM;
    pub fn scm_setsockopt(sfd: SCM, level: SCM, optname: SCM, value: SCM)
     -> SCM;
    pub fn scm_shutdown(sfd: SCM, how: SCM) -> SCM;
    pub fn scm_connect(sockfd: SCM, fam: SCM, address: SCM, args: SCM) -> SCM;
    pub fn scm_bind(sockfd: SCM, fam: SCM, address: SCM, args: SCM) -> SCM;
    pub fn scm_listen(sfd: SCM, backlog: SCM) -> SCM;
    pub fn scm_accept(sockfd: SCM) -> SCM;
    pub fn scm_getsockname(sockfd: SCM) -> SCM;
    pub fn scm_getpeername(sockfd: SCM) -> SCM;
    pub fn scm_recv(sockfd: SCM, buff_or_size: SCM, flags: SCM) -> SCM;
    pub fn scm_send(sockfd: SCM, message: SCM, flags: SCM) -> SCM;
    pub fn scm_recvfrom(sockfd: SCM, buff_or_size: SCM, flags: SCM,
                        offset: SCM, length: SCM) -> SCM;
    pub fn scm_sendto(sockfd: SCM, message: SCM, fam: SCM, address: SCM,
                      args_and_flags: SCM) -> SCM;
    pub fn scm_init_socket();
    pub fn scm_from_sockaddr(address: *const Struct_sockaddr,
                             addr_size: c_uint) -> SCM;
    pub fn scm_to_sockaddr(address: SCM, adress_size: *mut size_t)
     -> *mut Struct_sockaddr;
    pub fn scm_c_make_socket_address(family: SCM, address: SCM, args: SCM,
                                     address_size: *mut size_t)
     -> *mut Struct_sockaddr;
    pub fn scm_make_socket_address(family: SCM, address: SCM, args: SCM)
     -> SCM;
    pub fn scm_restricted_vector_sort_x(vec: SCM, less: SCM, startpos: SCM,
                                        endpos: SCM) -> SCM;
    pub fn scm_sorted_p(ls: SCM, less: SCM) -> SCM;
    pub fn scm_merge(ls1: SCM, ls2: SCM, less: SCM) -> SCM;
    pub fn scm_merge_x(ls1: SCM, ls2: SCM, less: SCM) -> SCM;
    pub fn scm_sort(ls: SCM, less: SCM) -> SCM;
    pub fn scm_sort_x(ls: SCM, less: SCM) -> SCM;
    pub fn scm_stable_sort(ls: SCM, less: SCM) -> SCM;
    pub fn scm_stable_sort_x(ls: SCM, less: SCM) -> SCM;
    pub fn scm_sort_list(ls: SCM, less: SCM) -> SCM;
    pub fn scm_sort_list_x(ls: SCM, less: SCM) -> SCM;
    pub fn scm_init_sort();
    pub fn scm_supports_source_properties_p(obj: SCM) -> SCM;
    pub fn scm_make_srcprops(line: c_long,
                             col: c_int, fname: SCM,
                             copy: SCM, plist: SCM) -> SCM;
    pub fn scm_source_property(obj: SCM, key: SCM) -> SCM;
    pub fn scm_set_source_property_x(obj: SCM, key: SCM, datum: SCM) -> SCM;
    pub fn scm_source_properties(obj: SCM) -> SCM;
    pub fn scm_set_source_properties_x(obj: SCM, props: SCM) -> SCM;
    pub fn scm_i_has_source_properties(obj: SCM) -> c_int;
    pub fn scm_i_set_source_properties_x(obj: SCM,
                                         line: c_long,
                                         col: c_int,
                                         fname: SCM);
    pub fn scm_cons_source(xorig: SCM, x: SCM, y: SCM) -> SCM;
    pub fn scm_init_srcprop();
    pub fn scm_report_stack_overflow();
    pub fn scm_stack_size(start: *mut SCM_STACKITEM)
     -> c_long;
    pub fn scm_stack_report();
    pub fn scm_sys_get_stack_size() -> SCM;
    pub fn scm_init_stackchk();
    pub fn scm_c_get_internal_run_time() -> c_long;
    pub fn scm_get_internal_real_time() -> SCM;
    pub fn scm_get_internal_run_time() -> SCM;
    pub fn scm_current_time() -> SCM;
    pub fn scm_gettimeofday() -> SCM;
    pub fn scm_localtime(time: SCM, zone: SCM) -> SCM;
    pub fn scm_gmtime(time: SCM) -> SCM;
    pub fn scm_mktime(sbd_time: SCM, zone: SCM) -> SCM;
    pub fn scm_tzset() -> SCM;
    pub fn scm_times() -> SCM;
    pub fn scm_strftime(format: SCM, stime: SCM) -> SCM;
    pub fn scm_strptime(format: SCM, string: SCM) -> SCM;
    pub fn scm_init_stime();
    pub fn scm_string_null_p(s: SCM) -> SCM;
    pub fn scm_string_any(pred: SCM, s: SCM, start: SCM, end: SCM) -> SCM;
    pub fn scm_string_every(pred: SCM, s: SCM, start: SCM, end: SCM) -> SCM;
    pub fn scm_string_tabulate(_proc: SCM, len: SCM) -> SCM;
    pub fn scm_string_to_list(str: SCM) -> SCM;
    pub fn scm_substring_to_list(str: SCM, start: SCM, end: SCM) -> SCM;
    pub fn scm_reverse_list_to_string(chrs: SCM) -> SCM;
    pub fn scm_string_join(ls: SCM, delimiter: SCM, grammar: SCM) -> SCM;
    pub fn scm_string_copy(str: SCM) -> SCM;
    pub fn scm_string_copy_x(target: SCM, tstart: SCM, s: SCM, start: SCM,
                             end: SCM) -> SCM;
    pub fn scm_substring_move_x(str1: SCM, start1: SCM, end1: SCM, str2: SCM,
                                start2: SCM) -> SCM;
    pub fn scm_string_take(s: SCM, n: SCM) -> SCM;
    pub fn scm_string_drop(s: SCM, n: SCM) -> SCM;
    pub fn scm_string_take_right(s: SCM, n: SCM) -> SCM;
    pub fn scm_string_drop_right(s: SCM, n: SCM) -> SCM;
    pub fn scm_string_pad(s: SCM, len: SCM, chr: SCM, start: SCM, end: SCM)
     -> SCM;
    pub fn scm_string_pad_right(s: SCM, len: SCM, chr: SCM, start: SCM,
                                end: SCM) -> SCM;
    pub fn scm_string_trim(s: SCM, char_pred: SCM, start: SCM, end: SCM)
     -> SCM;
    pub fn scm_string_trim_right(s: SCM, char_pred: SCM, start: SCM, end: SCM)
     -> SCM;
    pub fn scm_string_trim_both(s: SCM, char_pred: SCM, start: SCM, end: SCM)
     -> SCM;
    pub fn scm_substring_fill_x(str: SCM, chr: SCM, start: SCM, end: SCM)
     -> SCM;
    pub fn scm_string_fill_x(str: SCM, chr: SCM) -> SCM;
    pub fn scm_string_compare(s1: SCM, s2: SCM, proc_lt: SCM, proc_eq: SCM,
                              proc_gt: SCM, start1: SCM, end1: SCM,
                              start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_compare_ci(s1: SCM, s2: SCM, proc_lt: SCM, proc_eq: SCM,
                                 proc_gt: SCM, start1: SCM, end1: SCM,
                                 start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_eq(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                         start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_neq(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                          start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_lt(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                         start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_gt(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                         start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_le(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                         start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_ge(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                         start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_ci_eq(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                            start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_ci_neq(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                             start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_ci_lt(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                            start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_ci_gt(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                            start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_ci_le(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                            start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_ci_ge(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                            start2: SCM, end2: SCM) -> SCM;
    pub fn scm_substring_hash(s: SCM, bound: SCM, start: SCM, end: SCM)
     -> SCM;
    pub fn scm_substring_hash_ci(s: SCM, bound: SCM, start: SCM, end: SCM)
     -> SCM;
    pub fn scm_string_prefix_length(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                                    start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_prefix_length_ci(s1: SCM, s2: SCM, start1: SCM,
                                       end1: SCM, start2: SCM, end2: SCM)
     -> SCM;
    pub fn scm_string_suffix_length(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                                    start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_suffix_length_ci(s1: SCM, s2: SCM, start1: SCM,
                                       end1: SCM, start2: SCM, end2: SCM)
     -> SCM;
    pub fn scm_string_prefix_p(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                               start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_prefix_ci_p(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                                  start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_suffix_p(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                               start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_suffix_ci_p(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                                  start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_index(s: SCM, char_pred: SCM, start: SCM, end: SCM)
     -> SCM;
    pub fn scm_string_index_right(s: SCM, char_pred: SCM, start: SCM,
                                  end: SCM) -> SCM;
    pub fn scm_string_rindex(s: SCM, char_pred: SCM, start: SCM, end: SCM)
     -> SCM;
    pub fn scm_string_skip(s: SCM, char_pred: SCM, start: SCM, end: SCM)
     -> SCM;
    pub fn scm_string_skip_right(s: SCM, char_pred: SCM, start: SCM, end: SCM)
     -> SCM;
    pub fn scm_string_count(s: SCM, char_pred: SCM, start: SCM, end: SCM)
     -> SCM;
    pub fn scm_string_contains(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                               start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_contains_ci(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                                  start2: SCM, end2: SCM) -> SCM;
    pub fn scm_substring_upcase_x(str: SCM, start: SCM, end: SCM) -> SCM;
    pub fn scm_substring_upcase(str: SCM, start: SCM, end: SCM) -> SCM;
    pub fn scm_string_upcase_x(str: SCM) -> SCM;
    pub fn scm_string_upcase(str: SCM) -> SCM;
    pub fn scm_substring_downcase_x(str: SCM, start: SCM, end: SCM) -> SCM;
    pub fn scm_substring_downcase(str: SCM, start: SCM, end: SCM) -> SCM;
    pub fn scm_string_downcase_x(str: SCM) -> SCM;
    pub fn scm_string_downcase(str: SCM) -> SCM;
    pub fn scm_string_titlecase_x(str: SCM, start: SCM, end: SCM) -> SCM;
    pub fn scm_string_titlecase(str: SCM, start: SCM, end: SCM) -> SCM;
    pub fn scm_string_capitalize_x(str: SCM) -> SCM;
    pub fn scm_string_capitalize(str: SCM) -> SCM;
    pub fn scm_string_reverse(str: SCM, start: SCM, end: SCM) -> SCM;
    pub fn scm_string_reverse_x(str: SCM, start: SCM, end: SCM) -> SCM;
    pub fn scm_string_append_shared(ls: SCM) -> SCM;
    pub fn scm_string_concatenate(ls: SCM) -> SCM;
    pub fn scm_string_concatenate_shared(ls: SCM) -> SCM;
    pub fn scm_string_concatenate_reverse(ls: SCM, final_string: SCM,
                                          end: SCM) -> SCM;
    pub fn scm_string_concatenate_reverse_shared(ls: SCM, final_string: SCM,
                                                 end: SCM) -> SCM;
    pub fn scm_string_map(_proc: SCM, s: SCM, start: SCM, end: SCM) -> SCM;
    pub fn scm_string_map_x(_proc: SCM, s: SCM, start: SCM, end: SCM) -> SCM;
    pub fn scm_string_fold(kons: SCM, knil: SCM, s: SCM, start: SCM, end: SCM)
     -> SCM;
    pub fn scm_string_fold_right(kons: SCM, knil: SCM, s: SCM, start: SCM,
                                 end: SCM) -> SCM;
    pub fn scm_string_unfold(p: SCM, f: SCM, g: SCM, seed: SCM, base: SCM,
                             make_final: SCM) -> SCM;
    pub fn scm_string_unfold_right(p: SCM, f: SCM, g: SCM, seed: SCM,
                                   base: SCM, make_final: SCM) -> SCM;
    pub fn scm_string_for_each(_proc: SCM, s: SCM, start: SCM, end: SCM)
     -> SCM;
    pub fn scm_string_for_each_index(_proc: SCM, s: SCM, start: SCM, end: SCM)
     -> SCM;
    pub fn scm_xsubstring(s: SCM, from: SCM, to: SCM, start: SCM, end: SCM)
     -> SCM;
    pub fn scm_string_xcopy_x(target: SCM, tstart: SCM, s: SCM, sfrom: SCM,
                              sto: SCM, start: SCM, end: SCM) -> SCM;
    pub fn scm_string_replace(s1: SCM, s2: SCM, start1: SCM, end1: SCM,
                              start2: SCM, end2: SCM) -> SCM;
    pub fn scm_string_tokenize(s: SCM, token_char: SCM, start: SCM, end: SCM)
     -> SCM;
    pub fn scm_string_split(s: SCM, char_pred: SCM) -> SCM;
    pub fn scm_string_filter(char_pred: SCM, s: SCM, start: SCM, end: SCM)
     -> SCM;
    pub fn scm_string_delete(char_pred: SCM, s: SCM, start: SCM, end: SCM)
     -> SCM;
    pub fn scm_init_srfi_13();
    pub fn scm_init_srfi_13_14();
    pub fn scm_i_charset_get(cs: *mut scm_t_char_set, n: scm_t_wchar)
     -> c_int;
    pub fn scm_i_charset_set(cs: *mut scm_t_char_set, n: scm_t_wchar);
    pub fn scm_i_charset_unset(cs: *mut scm_t_char_set, n: scm_t_wchar);
    pub fn scm_char_set_p(obj: SCM) -> SCM;
    pub fn scm_char_set_eq(char_sets: SCM) -> SCM;
    pub fn scm_char_set_leq(char_sets: SCM) -> SCM;
    pub fn scm_char_set_hash(cs: SCM, bound: SCM) -> SCM;
    pub fn scm_char_set_cursor(cs: SCM) -> SCM;
    pub fn scm_char_set_ref(cs: SCM, cursor: SCM) -> SCM;
    pub fn scm_char_set_cursor_next(cs: SCM, cursor: SCM) -> SCM;
    pub fn scm_end_of_char_set_p(cursor: SCM) -> SCM;
    pub fn scm_char_set_fold(kons: SCM, knil: SCM, cs: SCM) -> SCM;
    pub fn scm_char_set_unfold(p: SCM, f: SCM, g: SCM, seed: SCM,
                               base_cs: SCM) -> SCM;
    pub fn scm_char_set_unfold_x(p: SCM, f: SCM, g: SCM, seed: SCM,
                                 base_cs: SCM) -> SCM;
    pub fn scm_char_set_for_each(_proc: SCM, cs: SCM) -> SCM;
    pub fn scm_char_set_map(_proc: SCM, cs: SCM) -> SCM;
    pub fn scm_char_set_copy(cs: SCM) -> SCM;
    pub fn scm_char_set(rest: SCM) -> SCM;
    pub fn scm_list_to_char_set(list: SCM, base_cs: SCM) -> SCM;
    pub fn scm_list_to_char_set_x(list: SCM, base_cs: SCM) -> SCM;
    pub fn scm_string_to_char_set(str: SCM, base_cs: SCM) -> SCM;
    pub fn scm_string_to_char_set_x(str: SCM, base_cs: SCM) -> SCM;
    pub fn scm_char_set_filter(pred: SCM, cs: SCM, base_cs: SCM) -> SCM;
    pub fn scm_char_set_filter_x(pred: SCM, cs: SCM, base_cs: SCM) -> SCM;
    pub fn scm_ucs_range_to_char_set(lower: SCM, upper: SCM, error: SCM,
                                     base_cs: SCM) -> SCM;
    pub fn scm_ucs_range_to_char_set_x(lower: SCM, upper: SCM, error: SCM,
                                       base_cs: SCM) -> SCM;
    pub fn scm_to_char_set(x: SCM) -> SCM;
    pub fn scm_char_set_size(cs: SCM) -> SCM;
    pub fn scm_char_set_count(pred: SCM, cs: SCM) -> SCM;
    pub fn scm_char_set_to_list(cs: SCM) -> SCM;
    pub fn scm_char_set_to_string(cs: SCM) -> SCM;
    pub fn scm_char_set_contains_p(cs: SCM, ch: SCM) -> SCM;
    pub fn scm_char_set_every(pred: SCM, cs: SCM) -> SCM;
    pub fn scm_char_set_any(pred: SCM, cs: SCM) -> SCM;
    pub fn scm_char_set_adjoin(cs: SCM, rest: SCM) -> SCM;
    pub fn scm_char_set_delete(cs: SCM, rest: SCM) -> SCM;
    pub fn scm_char_set_adjoin_x(cs: SCM, rest: SCM) -> SCM;
    pub fn scm_char_set_delete_x(cs: SCM, rest: SCM) -> SCM;
    pub fn scm_char_set_complement(cs: SCM) -> SCM;
    pub fn scm_char_set_union(rest: SCM) -> SCM;
    pub fn scm_char_set_intersection(rest: SCM) -> SCM;
    pub fn scm_char_set_difference(cs1: SCM, rest: SCM) -> SCM;
    pub fn scm_char_set_xor(rest: SCM) -> SCM;
    pub fn scm_char_set_diff_plus_intersection(cs1: SCM, rest: SCM) -> SCM;
    pub fn scm_char_set_complement_x(cs: SCM) -> SCM;
    pub fn scm_char_set_union_x(cs1: SCM, rest: SCM) -> SCM;
    pub fn scm_char_set_intersection_x(cs1: SCM, rest: SCM) -> SCM;
    pub fn scm_char_set_difference_x(cs1: SCM, rest: SCM) -> SCM;
    pub fn scm_char_set_xor_x(cs1: SCM, rest: SCM) -> SCM;
    pub fn scm_char_set_diff_plus_intersection_x(cs1: SCM, cs2: SCM,
                                                 rest: SCM) -> SCM;
    pub fn scm_sys_char_set_dump(charset: SCM) -> SCM;
    pub fn scm_init_srfi_14();
    pub fn scm_string_equal_p(s1: SCM, s2: SCM) -> SCM;
    pub fn scm_string_ci_equal_p(s1: SCM, s2: SCM) -> SCM;
    pub fn scm_string_less_p(s1: SCM, s2: SCM) -> SCM;
    pub fn scm_string_leq_p(s1: SCM, s2: SCM) -> SCM;
    pub fn scm_string_gr_p(s1: SCM, s2: SCM) -> SCM;
    pub fn scm_string_geq_p(s1: SCM, s2: SCM) -> SCM;
    pub fn scm_string_ci_less_p(s1: SCM, s2: SCM) -> SCM;
    pub fn scm_string_ci_leq_p(s1: SCM, s2: SCM) -> SCM;
    pub fn scm_string_ci_gr_p(s1: SCM, s2: SCM) -> SCM;
    pub fn scm_string_ci_geq_p(s1: SCM, s2: SCM) -> SCM;
    pub fn scm_init_strorder();
    pub fn scm_mkstrport(pos: SCM, str: SCM, modes: c_long,
                         caller: *const c_char) -> SCM;
    pub fn scm_strport_to_string(port: SCM) -> SCM;
    pub fn scm_object_to_string(obj: SCM, printer: SCM) -> SCM;
    pub fn scm_call_with_output_string(_proc: SCM) -> SCM;
    pub fn scm_call_with_input_string(str: SCM, _proc: SCM) -> SCM;
    pub fn scm_open_input_string(str: SCM) -> SCM;
    pub fn scm_open_output_string() -> SCM;
    pub fn scm_get_output_string(port: SCM) -> SCM;
    pub fn scm_c_read_string(expr: *const c_char) -> SCM;
    pub fn scm_c_eval_string(expr: *const c_char) -> SCM;
    pub fn scm_c_eval_string_in_module(expr: *const c_char,
                                       module: SCM) -> SCM;
    pub fn scm_eval_string(string: SCM) -> SCM;
    pub fn scm_eval_string_in_module(string: SCM, module: SCM) -> SCM;
    pub fn scm_init_strports();
    pub fn scm_symbol_p(x: SCM) -> SCM;
    pub fn scm_symbol_interned_p(sym: SCM) -> SCM;
    pub fn scm_make_symbol(name: SCM) -> SCM;
    pub fn scm_symbol_to_string(s: SCM) -> SCM;
    pub fn scm_string_to_symbol(s: SCM) -> SCM;
    pub fn scm_string_ci_to_symbol(s: SCM) -> SCM;
    pub fn scm_symbol_fref(s: SCM) -> SCM;
    pub fn scm_symbol_pref(s: SCM) -> SCM;
    pub fn scm_symbol_fset_x(s: SCM, val: SCM) -> SCM;
    pub fn scm_symbol_pset_x(s: SCM, val: SCM) -> SCM;
    pub fn scm_symbol_hash(s: SCM) -> SCM;
    pub fn scm_gensym(prefix: SCM) -> SCM;
    pub fn scm_from_locale_symbol(str: *const c_char) -> SCM;
    pub fn scm_from_locale_symboln(str: *const c_char,
                                   len: size_t) -> SCM;
    pub fn scm_take_locale_symbol(sym: *mut c_char) -> SCM;
    pub fn scm_take_locale_symboln(sym: *mut c_char,
                                   len: size_t) -> SCM;
    pub fn scm_from_latin1_symbol(str: *const c_char) -> SCM;
    pub fn scm_from_latin1_symboln(str: *const c_char,
                                   len: size_t) -> SCM;
    pub fn scm_take_latin1_symbol(sym: *mut c_char) -> SCM;
    pub fn scm_take_latin1_symboln(sym: *mut c_char,
                                   len: size_t) -> SCM;
    pub fn scm_from_utf8_symbol(str: *const c_char) -> SCM;
    pub fn scm_from_utf8_symboln(str: *const c_char,
                                 len: size_t) -> SCM;
    pub fn scm_take_utf8_symbol(sym: *mut c_char) -> SCM;
    pub fn scm_take_utf8_symboln(sym: *mut c_char,
                                 len: size_t) -> SCM;
    pub fn scm_i_hash_symbol(obj: SCM, n: c_ulong,
                             closure: *mut c_void)
     -> c_ulong;
    pub fn scm_symbols_prehistory();
    pub fn scm_init_symbols();
    pub fn scm_init_trees();
    pub fn scm_array_handle_uniform_element_size(h: *mut scm_t_array_handle)
     -> size_t;
    pub fn scm_array_handle_uniform_element_bit_size(h:
                                                         *mut scm_t_array_handle)
     -> size_t;
    pub fn scm_array_handle_uniform_elements(h: *mut scm_t_array_handle)
     -> *const c_void;
    pub fn scm_array_handle_uniform_writable_elements(h:
                                                          *mut scm_t_array_handle)
     -> *mut c_void;
    pub fn scm_uniform_vector_p(v: SCM) -> SCM;
    pub fn scm_uniform_vector_length(v: SCM) -> SCM;
    pub fn scm_uniform_vector_element_type(v: SCM) -> SCM;
    pub fn scm_uniform_vector_element_size(v: SCM) -> SCM;
    pub fn scm_uniform_vector_ref(v: SCM, idx: SCM) -> SCM;
    pub fn scm_uniform_vector_set_x(v: SCM, idx: SCM, val: SCM) -> SCM;
    pub fn scm_uniform_vector_to_list(v: SCM) -> SCM;
    pub fn scm_uniform_vector_read_x(v: SCM, port_or_fd: SCM, start: SCM,
                                     end: SCM) -> SCM;
    pub fn scm_uniform_vector_write(v: SCM, port_or_fd: SCM, start: SCM,
                                    end: SCM) -> SCM;
    pub fn scm_is_uniform_vector(obj: SCM) -> c_int;
    pub fn scm_c_uniform_vector_length(v: SCM) -> size_t;
    pub fn scm_c_uniform_vector_ref(v: SCM, idx: size_t) -> SCM;
    pub fn scm_c_uniform_vector_set_x(v: SCM, idx: size_t, val: SCM);
    pub fn scm_uniform_vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
                                       lenp: *mut size_t, incp: *mut ssize_t)
     -> *const c_void;
    pub fn scm_uniform_vector_writable_elements(uvec: SCM,
                                                h: *mut scm_t_array_handle,
                                                lenp: *mut size_t,
                                                incp: *mut ssize_t)
     -> *mut c_void;
    pub fn scm_init_uniform();
    pub fn scm_i_extract_values_2(obj: SCM, p1: *mut SCM, p2: *mut SCM);
    pub fn scm_values(args: SCM) -> SCM;
    pub fn scm_c_values(base: *mut SCM, n: size_t) -> SCM;
    pub fn scm_c_nvalues(obj: SCM) -> size_t;
    pub fn scm_c_value_ref(obj: SCM, idx: size_t) -> SCM;
    pub fn scm_init_values();
    pub fn scm_make_variable(init: SCM) -> SCM;
    pub fn scm_make_undefined_variable() -> SCM;
    pub fn scm_variable_p(obj: SCM) -> SCM;
    pub fn scm_variable_ref(var: SCM) -> SCM;
    pub fn scm_variable_set_x(var: SCM, val: SCM) -> SCM;
    pub fn scm_variable_unset_x(var: SCM) -> SCM;
    pub fn scm_variable_bound_p(var: SCM) -> SCM;
    pub fn scm_i_variable_print(var: SCM, port: SCM,
                                pstate: *mut scm_print_state);
    pub fn scm_init_variable();
    pub fn scm_make_srfi_4_vector(_type: SCM, len: SCM, fill: SCM) -> SCM;
    pub fn scm_u8vector_p(obj: SCM) -> SCM;
    pub fn scm_make_u8vector(n: SCM, fill: SCM) -> SCM;
    pub fn scm_take_u8vector(data: *mut scm_t_uint8, n: size_t) -> SCM;
    pub fn scm_u8vector(l: SCM) -> SCM;
    pub fn scm_u8vector_length(uvec: SCM) -> SCM;
    pub fn scm_u8vector_ref(uvec: SCM, index: SCM) -> SCM;
    pub fn scm_u8vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
    pub fn scm_u8vector_to_list(uvec: SCM) -> SCM;
    pub fn scm_list_to_u8vector(l: SCM) -> SCM;
    pub fn scm_any_to_u8vector(obj: SCM) -> SCM;
    pub fn scm_array_handle_u8_elements(h: *mut scm_t_array_handle)
     -> *const scm_t_uint8;
    pub fn scm_array_handle_u8_writable_elements(h: *mut scm_t_array_handle)
     -> *mut scm_t_uint8;
    pub fn scm_u8vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
                                 lenp: *mut size_t, incp: *mut ssize_t)
     -> *const scm_t_uint8;
    pub fn scm_u8vector_writable_elements(uvec: SCM,
                                          h: *mut scm_t_array_handle,
                                          lenp: *mut size_t,
                                          incp: *mut ssize_t)
     -> *mut scm_t_uint8;
    pub fn scm_s8vector_p(obj: SCM) -> SCM;
    pub fn scm_make_s8vector(n: SCM, fill: SCM) -> SCM;
    pub fn scm_take_s8vector(data: *mut scm_t_int8, n: size_t) -> SCM;
    pub fn scm_s8vector(l: SCM) -> SCM;
    pub fn scm_s8vector_length(uvec: SCM) -> SCM;
    pub fn scm_s8vector_ref(uvec: SCM, index: SCM) -> SCM;
    pub fn scm_s8vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
    pub fn scm_s8vector_to_list(uvec: SCM) -> SCM;
    pub fn scm_list_to_s8vector(l: SCM) -> SCM;
    pub fn scm_any_to_s8vector(obj: SCM) -> SCM;
    pub fn scm_array_handle_s8_elements(h: *mut scm_t_array_handle)
     -> *const scm_t_int8;
    pub fn scm_array_handle_s8_writable_elements(h: *mut scm_t_array_handle)
     -> *mut scm_t_int8;
    pub fn scm_s8vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
                                 lenp: *mut size_t, incp: *mut ssize_t)
     -> *const scm_t_int8;
    pub fn scm_s8vector_writable_elements(uvec: SCM,
                                          h: *mut scm_t_array_handle,
                                          lenp: *mut size_t,
                                          incp: *mut ssize_t)
     -> *mut scm_t_int8;
    pub fn scm_u16vector_p(obj: SCM) -> SCM;
    pub fn scm_make_u16vector(n: SCM, fill: SCM) -> SCM;
    pub fn scm_take_u16vector(data: *mut scm_t_uint16, n: size_t) -> SCM;
    pub fn scm_u16vector(l: SCM) -> SCM;
    pub fn scm_u16vector_length(uvec: SCM) -> SCM;
    pub fn scm_u16vector_ref(uvec: SCM, index: SCM) -> SCM;
    pub fn scm_u16vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
    pub fn scm_u16vector_to_list(uvec: SCM) -> SCM;
    pub fn scm_list_to_u16vector(l: SCM) -> SCM;
    pub fn scm_any_to_u16vector(obj: SCM) -> SCM;
    pub fn scm_array_handle_u16_elements(h: *mut scm_t_array_handle)
     -> *const scm_t_uint16;
    pub fn scm_array_handle_u16_writable_elements(h: *mut scm_t_array_handle)
     -> *mut scm_t_uint16;
    pub fn scm_u16vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
                                  lenp: *mut size_t, incp: *mut ssize_t)
     -> *const scm_t_uint16;
    pub fn scm_u16vector_writable_elements(uvec: SCM,
                                           h: *mut scm_t_array_handle,
                                           lenp: *mut size_t,
                                           incp: *mut ssize_t)
     -> *mut scm_t_uint16;
    pub fn scm_s16vector_p(obj: SCM) -> SCM;
    pub fn scm_make_s16vector(n: SCM, fill: SCM) -> SCM;
    pub fn scm_take_s16vector(data: *mut scm_t_int16, n: size_t) -> SCM;
    pub fn scm_s16vector(l: SCM) -> SCM;
    pub fn scm_s16vector_length(uvec: SCM) -> SCM;
    pub fn scm_s16vector_ref(uvec: SCM, index: SCM) -> SCM;
    pub fn scm_s16vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
    pub fn scm_s16vector_to_list(uvec: SCM) -> SCM;
    pub fn scm_list_to_s16vector(l: SCM) -> SCM;
    pub fn scm_any_to_s16vector(obj: SCM) -> SCM;
    pub fn scm_array_handle_s16_elements(h: *mut scm_t_array_handle)
     -> *const scm_t_int16;
    pub fn scm_array_handle_s16_writable_elements(h: *mut scm_t_array_handle)
     -> *mut scm_t_int16;
    pub fn scm_s16vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
                                  lenp: *mut size_t, incp: *mut ssize_t)
     -> *const scm_t_int16;
    pub fn scm_s16vector_writable_elements(uvec: SCM,
                                           h: *mut scm_t_array_handle,
                                           lenp: *mut size_t,
                                           incp: *mut ssize_t)
     -> *mut scm_t_int16;
    pub fn scm_u32vector_p(obj: SCM) -> SCM;
    pub fn scm_make_u32vector(n: SCM, fill: SCM) -> SCM;
    pub fn scm_take_u32vector(data: *mut scm_t_uint32, n: size_t) -> SCM;
    pub fn scm_u32vector(l: SCM) -> SCM;
    pub fn scm_u32vector_length(uvec: SCM) -> SCM;
    pub fn scm_u32vector_ref(uvec: SCM, index: SCM) -> SCM;
    pub fn scm_u32vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
    pub fn scm_u32vector_to_list(uvec: SCM) -> SCM;
    pub fn scm_list_to_u32vector(l: SCM) -> SCM;
    pub fn scm_any_to_u32vector(obj: SCM) -> SCM;
    pub fn scm_array_handle_u32_elements(h: *mut scm_t_array_handle)
     -> *const scm_t_uint32;
    pub fn scm_array_handle_u32_writable_elements(h: *mut scm_t_array_handle)
     -> *mut scm_t_uint32;
    pub fn scm_u32vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
                                  lenp: *mut size_t, incp: *mut ssize_t)
     -> *const scm_t_uint32;
    pub fn scm_u32vector_writable_elements(uvec: SCM,
                                           h: *mut scm_t_array_handle,
                                           lenp: *mut size_t,
                                           incp: *mut ssize_t)
     -> *mut scm_t_uint32;
    pub fn scm_s32vector_p(obj: SCM) -> SCM;
    pub fn scm_make_s32vector(n: SCM, fill: SCM) -> SCM;
    pub fn scm_take_s32vector(data: *mut scm_t_int32, n: size_t) -> SCM;
    pub fn scm_s32vector(l: SCM) -> SCM;
    pub fn scm_s32vector_length(uvec: SCM) -> SCM;
    pub fn scm_s32vector_ref(uvec: SCM, index: SCM) -> SCM;
    pub fn scm_s32vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
    pub fn scm_s32vector_to_list(uvec: SCM) -> SCM;
    pub fn scm_list_to_s32vector(l: SCM) -> SCM;
    pub fn scm_any_to_s32vector(obj: SCM) -> SCM;
    pub fn scm_array_handle_s32_elements(h: *mut scm_t_array_handle)
     -> *const scm_t_int32;
    pub fn scm_array_handle_s32_writable_elements(h: *mut scm_t_array_handle)
     -> *mut scm_t_int32;
    pub fn scm_s32vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
                                  lenp: *mut size_t, incp: *mut ssize_t)
     -> *const scm_t_int32;
    pub fn scm_s32vector_writable_elements(uvec: SCM,
                                           h: *mut scm_t_array_handle,
                                           lenp: *mut size_t,
                                           incp: *mut ssize_t)
     -> *mut scm_t_int32;
    pub fn scm_u64vector_p(obj: SCM) -> SCM;
    pub fn scm_make_u64vector(n: SCM, fill: SCM) -> SCM;
    pub fn scm_u64vector(l: SCM) -> SCM;
    pub fn scm_u64vector_length(uvec: SCM) -> SCM;
    pub fn scm_u64vector_ref(uvec: SCM, index: SCM) -> SCM;
    pub fn scm_u64vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
    pub fn scm_u64vector_to_list(uvec: SCM) -> SCM;
    pub fn scm_list_to_u64vector(l: SCM) -> SCM;
    pub fn scm_any_to_u64vector(obj: SCM) -> SCM;
    pub fn scm_take_u64vector(data: *mut scm_t_uint64, n: size_t) -> SCM;
    pub fn scm_array_handle_u64_elements(h: *mut scm_t_array_handle)
     -> *const scm_t_uint64;
    pub fn scm_array_handle_u64_writable_elements(h: *mut scm_t_array_handle)
     -> *mut scm_t_uint64;
    pub fn scm_u64vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
                                  lenp: *mut size_t, incp: *mut ssize_t)
     -> *const scm_t_uint64;
    pub fn scm_u64vector_writable_elements(uvec: SCM,
                                           h: *mut scm_t_array_handle,
                                           lenp: *mut size_t,
                                           incp: *mut ssize_t)
     -> *mut scm_t_uint64;
    pub fn scm_s64vector_p(obj: SCM) -> SCM;
    pub fn scm_make_s64vector(n: SCM, fill: SCM) -> SCM;
    pub fn scm_s64vector(l: SCM) -> SCM;
    pub fn scm_s64vector_length(uvec: SCM) -> SCM;
    pub fn scm_s64vector_ref(uvec: SCM, index: SCM) -> SCM;
    pub fn scm_s64vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
    pub fn scm_s64vector_to_list(uvec: SCM) -> SCM;
    pub fn scm_list_to_s64vector(l: SCM) -> SCM;
    pub fn scm_any_to_s64vector(obj: SCM) -> SCM;
    pub fn scm_take_s64vector(data: *mut scm_t_int64, n: size_t) -> SCM;
    pub fn scm_array_handle_s64_elements(h: *mut scm_t_array_handle)
     -> *const scm_t_int64;
    pub fn scm_array_handle_s64_writable_elements(h: *mut scm_t_array_handle)
     -> *mut scm_t_int64;
    pub fn scm_s64vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
                                  lenp: *mut size_t, incp: *mut ssize_t)
     -> *const scm_t_int64;
    pub fn scm_s64vector_writable_elements(uvec: SCM,
                                           h: *mut scm_t_array_handle,
                                           lenp: *mut size_t,
                                           incp: *mut ssize_t)
     -> *mut scm_t_int64;
    pub fn scm_f32vector_p(obj: SCM) -> SCM;
    pub fn scm_make_f32vector(n: SCM, fill: SCM) -> SCM;
    pub fn scm_take_f32vector(data: *mut c_float, n: size_t)
     -> SCM;
    pub fn scm_f32vector(l: SCM) -> SCM;
    pub fn scm_f32vector_length(uvec: SCM) -> SCM;
    pub fn scm_f32vector_ref(uvec: SCM, index: SCM) -> SCM;
    pub fn scm_f32vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
    pub fn scm_f32vector_to_list(uvec: SCM) -> SCM;
    pub fn scm_list_to_f32vector(l: SCM) -> SCM;
    pub fn scm_any_to_f32vector(obj: SCM) -> SCM;
    pub fn scm_array_handle_f32_elements(h: *mut scm_t_array_handle)
     -> *const c_float;
    pub fn scm_array_handle_f32_writable_elements(h: *mut scm_t_array_handle)
     -> *mut c_float;
    pub fn scm_f32vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
                                  lenp: *mut size_t, incp: *mut ssize_t)
     -> *const c_float;
    pub fn scm_f32vector_writable_elements(uvec: SCM,
                                           h: *mut scm_t_array_handle,
                                           lenp: *mut size_t,
                                           incp: *mut ssize_t)
     -> *mut c_float;
    pub fn scm_f64vector_p(obj: SCM) -> SCM;
    pub fn scm_make_f64vector(n: SCM, fill: SCM) -> SCM;
    pub fn scm_take_f64vector(data: *mut c_double, n: size_t)
     -> SCM;
    pub fn scm_f64vector(l: SCM) -> SCM;
    pub fn scm_f64vector_length(uvec: SCM) -> SCM;
    pub fn scm_f64vector_ref(uvec: SCM, index: SCM) -> SCM;
    pub fn scm_f64vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
    pub fn scm_f64vector_to_list(uvec: SCM) -> SCM;
    pub fn scm_list_to_f64vector(l: SCM) -> SCM;
    pub fn scm_any_to_f64vector(obj: SCM) -> SCM;
    pub fn scm_array_handle_f64_elements(h: *mut scm_t_array_handle)
     -> *const c_double;
    pub fn scm_array_handle_f64_writable_elements(h: *mut scm_t_array_handle)
     -> *mut c_double;
    pub fn scm_f64vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
                                  lenp: *mut size_t, incp: *mut ssize_t)
     -> *const c_double;
    pub fn scm_f64vector_writable_elements(uvec: SCM,
                                           h: *mut scm_t_array_handle,
                                           lenp: *mut size_t,
                                           incp: *mut ssize_t)
     -> *mut c_double;
    pub fn scm_c32vector_p(obj: SCM) -> SCM;
    pub fn scm_make_c32vector(n: SCM, fill: SCM) -> SCM;
    pub fn scm_take_c32vector(data: *mut c_float, n: size_t)
     -> SCM;
    pub fn scm_c32vector(l: SCM) -> SCM;
    pub fn scm_c32vector_length(uvec: SCM) -> SCM;
    pub fn scm_c32vector_ref(uvec: SCM, index: SCM) -> SCM;
    pub fn scm_c32vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
    pub fn scm_c32vector_to_list(uvec: SCM) -> SCM;
    pub fn scm_list_to_c32vector(l: SCM) -> SCM;
    pub fn scm_any_to_c32vector(obj: SCM) -> SCM;
    pub fn scm_array_handle_c32_elements(h: *mut scm_t_array_handle)
     -> *const c_float;
    pub fn scm_array_handle_c32_writable_elements(h: *mut scm_t_array_handle)
     -> *mut c_float;
    pub fn scm_c32vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
                                  lenp: *mut size_t, incp: *mut ssize_t)
     -> *const c_float;
    pub fn scm_c32vector_writable_elements(uvec: SCM,
                                           h: *mut scm_t_array_handle,
                                           lenp: *mut size_t,
                                           incp: *mut ssize_t)
     -> *mut c_float;
    pub fn scm_c64vector_p(obj: SCM) -> SCM;
    pub fn scm_make_c64vector(n: SCM, fill: SCM) -> SCM;
    pub fn scm_take_c64vector(data: *mut c_double, n: size_t)
     -> SCM;
    pub fn scm_c64vector(l: SCM) -> SCM;
    pub fn scm_c64vector_length(uvec: SCM) -> SCM;
    pub fn scm_c64vector_ref(uvec: SCM, index: SCM) -> SCM;
    pub fn scm_c64vector_set_x(uvec: SCM, index: SCM, value: SCM) -> SCM;
    pub fn scm_c64vector_to_list(uvec: SCM) -> SCM;
    pub fn scm_list_to_c64vector(l: SCM) -> SCM;
    pub fn scm_any_to_c64vector(obj: SCM) -> SCM;
    pub fn scm_array_handle_c64_elements(h: *mut scm_t_array_handle)
     -> *const c_double;
    pub fn scm_array_handle_c64_writable_elements(h: *mut scm_t_array_handle)
     -> *mut c_double;
    pub fn scm_c64vector_elements(uvec: SCM, h: *mut scm_t_array_handle,
                                  lenp: *mut size_t, incp: *mut ssize_t)
     -> *const c_double;
    pub fn scm_c64vector_writable_elements(uvec: SCM,
                                           h: *mut scm_t_array_handle,
                                           lenp: *mut size_t,
                                           incp: *mut ssize_t)
     -> *mut c_double;
    pub fn scm_i_generalized_vector_type(vec: SCM) -> SCM;
    pub fn scm_i_uniform_vector_tag(uvec: SCM)
     -> *const c_char;
    pub fn scm_i_uniform_vector_ref_proc(uvec: SCM) -> scm_i_t_array_ref;
    pub fn scm_i_uniform_vector_set_proc(uvec: SCM) -> scm_i_t_array_set;
    pub fn scm_uniform_element_size(obj: SCM) -> size_t;
    pub fn scm_init_srfi_4();
    pub fn scm_major_version() -> SCM;
    pub fn scm_minor_version() -> SCM;
    pub fn scm_micro_version() -> SCM;
    pub fn scm_effective_version() -> SCM;
    pub fn scm_version() -> SCM;
    pub fn scm_init_version();
    pub fn scm_make_soft_port(pv: SCM, modes: SCM) -> SCM;
    pub fn scm_init_vports();
    pub fn scm_print_exception(port: SCM, frame: SCM, key: SCM, args: SCM)
     -> SCM;
    pub fn scm_display_error_message(message: SCM, args: SCM, port: SCM);
    pub fn scm_i_display_error(frame: SCM, port: SCM, subr: SCM, message: SCM,
                               args: SCM, rest: SCM);
    pub fn scm_display_error(frame: SCM, port: SCM, subr: SCM, message: SCM,
                             args: SCM, rest: SCM) -> SCM;
    pub fn scm_display_application(frame: SCM, port: SCM, indent: SCM) -> SCM;
    pub fn scm_display_backtrace(stack: SCM, port: SCM, first: SCM,
                                 depth: SCM) -> SCM;
    pub fn scm_display_backtrace_with_highlights(stack: SCM, port: SCM,
                                                 first: SCM, depth: SCM,
                                                 highlights: SCM) -> SCM;
    pub fn scm_backtrace() -> SCM;
    pub fn scm_backtrace_with_highlights(highlights: SCM) -> SCM;
    pub fn scm_init_backtrace();
    pub fn scm_c_make_objcode_slice(parent: SCM, ptr: *const scm_t_uint8)
     -> SCM;
    pub fn scm_load_objcode(file: SCM) -> SCM;
    pub fn scm_objcode_p(obj: SCM) -> SCM;
    pub fn scm_objcode_meta(objcode: SCM) -> SCM;
    pub fn scm_bytecode_to_objcode(bytecode: SCM) -> SCM;
    pub fn scm_bytecode_to_native_objcode(bytecode: SCM) -> SCM;
    pub fn scm_objcode_to_bytecode(objcode: SCM) -> SCM;
    pub fn scm_write_objcode(objcode: SCM, port: SCM) -> SCM;
    pub fn scm_i_objcode_print(objcode: SCM, port: SCM,
                               pstate: *mut scm_print_state);
    pub fn scm_bootstrap_objcodes();
    pub fn scm_init_objcodes();
    pub fn scm_make_program(objcode: SCM, objtable: SCM, free_variables: SCM)
     -> SCM;
    pub fn scm_program_p(obj: SCM) -> SCM;
    pub fn scm_program_base(program: SCM) -> SCM;
    pub fn scm_program_meta(program: SCM) -> SCM;
    pub fn scm_program_bindings(program: SCM) -> SCM;
    pub fn scm_program_sources(program: SCM) -> SCM;
    pub fn scm_program_source(program: SCM, ip: SCM, sources: SCM) -> SCM;
    pub fn scm_program_arities(program: SCM) -> SCM;
    pub fn scm_program_objects(program: SCM) -> SCM;
    pub fn scm_program_module(program: SCM) -> SCM;
    pub fn scm_program_num_free_variables(program: SCM) -> SCM;
    pub fn scm_program_free_variable_ref(program: SCM, i: SCM) -> SCM;
    pub fn scm_program_free_variable_set_x(program: SCM, i: SCM, x: SCM)
     -> SCM;
    pub fn scm_program_objcode(program: SCM) -> SCM;
    pub fn scm_i_program_properties(program: SCM) -> SCM;
    pub fn scm_i_program_arity(program: SCM, req: *mut c_int,
                               opt: *mut c_int,
                               rest: *mut c_int)
     -> c_int;
    pub fn scm_i_program_print(program: SCM, port: SCM,
                               pstate: *mut scm_print_state);
    pub fn scm_bootstrap_programs();
    pub fn scm_init_programs();
    pub fn scm_c_make_frame(stack_holder: SCM, fp: *mut SCM, sp: *mut SCM,
                            ip: *mut scm_t_uint8, offset: scm_t_ptrdiff)
     -> SCM;
    pub fn scm_frame_p(obj: SCM) -> SCM;
    pub fn scm_frame_procedure(frame: SCM) -> SCM;
    pub fn scm_frame_arguments(frame: SCM) -> SCM;
    pub fn scm_frame_source(frame: SCM) -> SCM;
    pub fn scm_frame_num_locals(frame: SCM) -> SCM;
    pub fn scm_frame_local_ref(frame: SCM, index: SCM) -> SCM;
    pub fn scm_frame_local_set_x(frame: SCM, index: SCM, val: SCM) -> SCM;
    pub fn scm_frame_address(frame: SCM) -> SCM;
    pub fn scm_frame_stack_pointer(frame: SCM) -> SCM;
    pub fn scm_frame_instruction_pointer(frame: SCM) -> SCM;
    pub fn scm_frame_return_address(frame: SCM) -> SCM;
    pub fn scm_frame_mv_return_address(frame: SCM) -> SCM;
    pub fn scm_frame_dynamic_link(frame: SCM) -> SCM;
    pub fn scm_frame_previous(frame: SCM) -> SCM;
    pub fn scm_i_frame_print(frame: SCM, port: SCM,
                             pstate: *mut scm_print_state);
    pub fn scm_init_frames();
    pub fn scm_stack_p(obj: SCM) -> SCM;
    pub fn scm_make_stack(obj: SCM, args: SCM) -> SCM;
    pub fn scm_stack_id(stack: SCM) -> SCM;
    pub fn scm_stack_ref(stack: SCM, i: SCM) -> SCM;
    pub fn scm_stack_length(stack: SCM) -> SCM;
    pub fn scm_init_stacks();
    pub fn __underflow(arg1: *mut _IO_FILE) -> c_int;
    pub fn __uflow(arg1: *mut _IO_FILE) -> c_int;
    pub fn __overflow(arg1: *mut _IO_FILE, arg2: c_int)
     -> c_int;
    pub fn _IO_getc(__fp: *mut _IO_FILE) -> c_int;
    pub fn _IO_putc(__c: c_int, __fp: *mut _IO_FILE)
     -> c_int;
    pub fn _IO_feof(__fp: *mut _IO_FILE) -> c_int;
    pub fn _IO_ferror(__fp: *mut _IO_FILE) -> c_int;
    pub fn _IO_peekc_locked(__fp: *mut _IO_FILE) -> 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) -> c_int;
    pub fn _IO_vfscanf(arg1: *mut _IO_FILE,
                       arg2: *const c_char,
                       arg3: __gnuc_va_list, arg4: *mut c_int)
     -> c_int;
    pub fn _IO_vfprintf(arg1: *mut _IO_FILE,
                        arg2: *const c_char,
                        arg3: __gnuc_va_list) -> c_int;
    pub fn _IO_padn(arg1: *mut _IO_FILE, arg2: c_int,
                    arg3: __ssize_t) -> __ssize_t;
    pub fn _IO_sgetn(arg1: *mut _IO_FILE, arg2: *mut c_void,
                     arg3: size_t) -> size_t;
    pub fn _IO_seekoff(arg1: *mut _IO_FILE, arg2: __off64_t,
                       arg3: c_int,
                       arg4: c_int) -> __off64_t;
    pub fn _IO_seekpos(arg1: *mut _IO_FILE, arg2: __off64_t,
                       arg3: c_int) -> __off64_t;
    pub fn _IO_free_backup_area(arg1: *mut _IO_FILE);
    pub fn remove(__filename: *const c_char)
     -> c_int;
    pub fn rename(__old: *const c_char,
                  __new: *const c_char)
     -> c_int;
    pub fn renameat(__oldfd: c_int,
                    __old: *const c_char,
                    __newfd: c_int,
                    __new: *const c_char)
     -> c_int;
    pub fn tmpfile() -> *mut FILE;
    pub fn tmpnam(__s: *mut c_char)
     -> *mut c_char;
    pub fn tmpnam_r(__s: *mut c_char)
     -> *mut c_char;
    pub fn tempnam(__dir: *const c_char,
                   __pfx: *const c_char)
     -> *mut c_char;
    pub fn fclose(__stream: *mut FILE) -> c_int;
    pub fn fflush(__stream: *mut FILE) -> c_int;
    pub fn fflush_unlocked(__stream: *mut FILE) -> c_int;
    pub fn fopen(__filename: *const c_char,
                 __modes: *const c_char) -> *mut FILE;
    pub fn freopen(__filename: *const c_char,
                   __modes: *const c_char,
                   __stream: *mut FILE) -> *mut FILE;
    pub fn fdopen(__fd: c_int,
                  __modes: *const c_char) -> *mut FILE;
    pub fn fmemopen(__s: *mut c_void, __len: size_t,
                    __modes: *const c_char) -> *mut FILE;
    pub fn open_memstream(__bufloc: *mut *mut c_char,
                          __sizeloc: *mut size_t) -> *mut FILE;
    pub fn setbuf(__stream: *mut FILE, __buf: *mut c_char);
    pub fn setvbuf(__stream: *mut FILE, __buf: *mut c_char,
                   __modes: c_int, __n: size_t)
     -> c_int;
    pub fn setbuffer(__stream: *mut FILE, __buf: *mut c_char,
                     __size: size_t);
    pub fn setlinebuf(__stream: *mut FILE);
    pub fn fprintf(__stream: *mut FILE,
                   __format: *const c_char, ...)
     -> c_int;
    pub fn printf(__format: *const c_char, ...)
     -> c_int;
    pub fn sprintf(__s: *mut c_char,
                   __format: *const c_char, ...)
     -> c_int;
    pub fn vfprintf(__s: *mut FILE, __format: *const c_char,
                    __arg: __gnuc_va_list) -> c_int;
    pub fn vprintf(__format: *const c_char,
                   __arg: __gnuc_va_list) -> c_int;
    pub fn vsprintf(__s: *mut c_char,
                    __format: *const c_char,
                    __arg: __gnuc_va_list) -> c_int;
    pub fn snprintf(__s: *mut c_char, __maxlen: size_t,
                    __format: *const c_char, ...)
     -> c_int;
    pub fn vsnprintf(__s: *mut c_char, __maxlen: size_t,
                     __format: *const c_char,
                     __arg: __gnuc_va_list) -> c_int;
    pub fn vdprintf(__fd: c_int,
                    __fmt: *const c_char,
                    __arg: __gnuc_va_list) -> c_int;
    pub fn dprintf(__fd: c_int,
                   __fmt: *const c_char, ...)
     -> c_int;
    pub fn fscanf(__stream: *mut FILE,
                  __format: *const c_char, ...)
     -> c_int;
    pub fn scanf(__format: *const c_char, ...)
     -> c_int;
    pub fn sscanf(__s: *const c_char,
                  __format: *const c_char, ...)
     -> c_int;
    pub fn vfscanf(__s: *mut FILE, __format: *const c_char,
                   __arg: __gnuc_va_list) -> c_int;
    pub fn vscanf(__format: *const c_char,
                  __arg: __gnuc_va_list) -> c_int;
    pub fn vsscanf(__s: *const c_char,
                   __format: *const c_char,
                   __arg: __gnuc_va_list) -> c_int;
    pub fn fgetc(__stream: *mut FILE) -> c_int;
    pub fn getc(__stream: *mut FILE) -> c_int;
    pub fn getchar() -> c_int;
    pub fn getc_unlocked(__stream: *mut FILE) -> c_int;
    pub fn getchar_unlocked() -> c_int;
    pub fn fgetc_unlocked(__stream: *mut FILE) -> c_int;
    pub fn fputc(__c: c_int, __stream: *mut FILE)
     -> c_int;
    pub fn putc(__c: c_int, __stream: *mut FILE)
     -> c_int;
    pub fn putchar(__c: c_int) -> c_int;
    pub fn fputc_unlocked(__c: c_int, __stream: *mut FILE)
     -> c_int;
    pub fn putc_unlocked(__c: c_int, __stream: *mut FILE)
     -> c_int;
    pub fn putchar_unlocked(__c: c_int)
     -> c_int;
    pub fn getw(__stream: *mut FILE) -> c_int;
    pub fn putw(__w: c_int, __stream: *mut FILE)
     -> c_int;
    pub fn fgets(__s: *mut c_char, __n: c_int,
                 __stream: *mut FILE) -> *mut c_char;
    pub fn __getdelim(__lineptr: *mut *mut c_char,
                      __n: *mut size_t, __delimiter: c_int,
                      __stream: *mut FILE) -> __ssize_t;
    pub fn getdelim(__lineptr: *mut *mut c_char,
                    __n: *mut size_t, __delimiter: c_int,
                    __stream: *mut FILE) -> __ssize_t;
    pub fn getline(__lineptr: *mut *mut c_char,
                   __n: *mut size_t, __stream: *mut FILE) -> __ssize_t;
    pub fn fputs(__s: *const c_char, __stream: *mut FILE)
     -> c_int;
    pub fn puts(__s: *const c_char) -> c_int;
    pub fn ungetc(__c: c_int, __stream: *mut FILE)
     -> c_int;
    pub fn fread(__ptr: *mut c_void, __size: size_t,
                 __n: size_t, __stream: *mut FILE) -> size_t;
    pub fn fwrite(__ptr: *const c_void, __size: size_t,
                  __n: size_t, __s: *mut FILE) -> size_t;
    pub fn fread_unlocked(__ptr: *mut c_void, __size: size_t,
                          __n: size_t, __stream: *mut FILE) -> size_t;
    pub fn fwrite_unlocked(__ptr: *const c_void,
                           __size: size_t, __n: size_t, __stream: *mut FILE)
     -> size_t;
    pub fn fseek(__stream: *mut FILE, __off: c_long,
                 __whence: c_int) -> c_int;
    pub fn ftell(__stream: *mut FILE) -> c_long;
    pub fn rewind(__stream: *mut FILE);
    pub fn fseeko(__stream: *mut FILE, __off: __off_t,
                  __whence: c_int) -> c_int;
    pub fn ftello(__stream: *mut FILE) -> __off_t;
    pub fn fgetpos(__stream: *mut FILE, __pos: *mut fpos_t)
     -> c_int;
    pub fn fsetpos(__stream: *mut FILE, __pos: *const fpos_t)
     -> c_int;
    pub fn clearerr(__stream: *mut FILE);
    pub fn feof(__stream: *mut FILE) -> c_int;
    pub fn ferror(__stream: *mut FILE) -> c_int;
    pub fn clearerr_unlocked(__stream: *mut FILE);
    pub fn feof_unlocked(__stream: *mut FILE) -> c_int;
    pub fn ferror_unlocked(__stream: *mut FILE) -> c_int;
    pub fn perror(__s: *const c_char);
    pub fn fileno(__stream: *mut FILE) -> c_int;
    pub fn fileno_unlocked(__stream: *mut FILE) -> c_int;
    pub fn popen(__command: *const c_char,
                 __modes: *const c_char) -> *mut FILE;
    pub fn pclose(__stream: *mut FILE) -> c_int;
    pub fn ctermid(__s: *mut c_char)
     -> *mut c_char;
    pub fn flockfile(__stream: *mut FILE);
    pub fn ftrylockfile(__stream: *mut FILE) -> c_int;
    pub fn funlockfile(__stream: *mut FILE);
    pub fn memcpy(__dest: *mut c_void,
                  __src: *const c_void, __n: size_t)
     -> *mut c_void;
    pub fn memmove(__dest: *mut c_void,
                   __src: *const c_void, __n: size_t)
     -> *mut c_void;
    pub fn memccpy(__dest: *mut c_void,
                   __src: *const c_void,
                   __c: c_int, __n: size_t)
     -> *mut c_void;
    pub fn memset(__s: *mut c_void,
                  __c: c_int, __n: size_t)
     -> *mut c_void;
    pub fn memcmp(__s1: *const c_void,
                  __s2: *const c_void, __n: size_t)
     -> c_int;
    pub fn memchr(__s: *const c_void,
                  __c: c_int, __n: size_t)
     -> *mut c_void;
    pub fn strcpy(__dest: *mut c_char,
                  __src: *const c_char)
     -> *mut c_char;
    pub fn strncpy(__dest: *mut c_char,
                   __src: *const c_char, __n: size_t)
     -> *mut c_char;
    pub fn strcat(__dest: *mut c_char,
                  __src: *const c_char)
     -> *mut c_char;
    pub fn strncat(__dest: *mut c_char,
                   __src: *const c_char, __n: size_t)
     -> *mut c_char;
    pub fn strcmp(__s1: *const c_char,
                  __s2: *const c_char)
     -> c_int;
    pub fn strncmp(__s1: *const c_char,
                   __s2: *const c_char, __n: size_t)
     -> c_int;
    pub fn strcoll(__s1: *const c_char,
                   __s2: *const c_char)
     -> c_int;
    pub fn strxfrm(__dest: *mut c_char,
                   __src: *const c_char, __n: size_t)
     -> size_t;
    pub fn strcoll_l(__s1: *const c_char,
                     __s2: *const c_char, __l: __locale_t)
     -> c_int;
    pub fn strxfrm_l(__dest: *mut c_char,
                     __src: *const c_char, __n: size_t,
                     __l: __locale_t) -> size_t;
    pub fn strdup(__s: *const c_char)
     -> *mut c_char;
    pub fn strndup(__string: *const c_char, __n: size_t)
     -> *mut c_char;
    pub fn strchr(__s: *const c_char,
                  __c: c_int) -> *mut c_char;
    pub fn strrchr(__s: *const c_char,
                   __c: c_int) -> *mut c_char;
    pub fn strcspn(__s: *const c_char,
                   __reject: *const c_char) -> size_t;
    pub fn strspn(__s: *const c_char,
                  __accept: *const c_char) -> size_t;
    pub fn strpbrk(__s: *const c_char,
                   __accept: *const c_char)
     -> *mut c_char;
    pub fn strstr(__haystack: *const c_char,
                  __needle: *const c_char)
     -> *mut c_char;
    pub fn strtok(__s: *mut c_char,
                  __delim: *const c_char)
     -> *mut c_char;
    pub fn __strtok_r(__s: *mut c_char,
                      __delim: *const c_char,
                      __save_ptr: *mut *mut c_char)
     -> *mut c_char;
    pub fn strtok_r(__s: *mut c_char,
                    __delim: *const c_char,
                    __save_ptr: *mut *mut c_char)
     -> *mut c_char;
    pub fn strlen(__s: *const c_char) -> size_t;
    pub fn strnlen(__string: *const c_char, __maxlen: size_t)
     -> size_t;
    pub fn strerror(__errnum: c_int)
     -> *mut c_char;
    pub fn strerror_r(__errnum: c_int,
                      __buf: *mut c_char, __buflen: size_t)
     -> c_int;
    pub fn strerror_l(__errnum: c_int, __l: __locale_t)
     -> *mut c_char;
    pub fn __bzero(__s: *mut c_void, __n: size_t);
    pub fn bcopy(__src: *const c_void,
                 __dest: *mut c_void, __n: size_t);
    pub fn bzero(__s: *mut c_void, __n: size_t);
    pub fn bcmp(__s1: *const c_void,
                __s2: *const c_void, __n: size_t)
     -> c_int;
    pub fn index(__s: *const c_char,
                 __c: c_int) -> *mut c_char;
    pub fn rindex(__s: *const c_char,
                  __c: c_int) -> *mut c_char;
    pub fn ffs(__i: c_int) -> c_int;
    pub fn strcasecmp(__s1: *const c_char,
                      __s2: *const c_char)
     -> c_int;
    pub fn strncasecmp(__s1: *const c_char,
                       __s2: *const c_char, __n: size_t)
     -> c_int;
    pub fn strsep(__stringp: *mut *mut c_char,
                  __delim: *const c_char)
     -> *mut c_char;
    pub fn strsignal(__sig: c_int)
     -> *mut c_char;
    pub fn __stpcpy(__dest: *mut c_char,
                    __src: *const c_char)
     -> *mut c_char;
    pub fn stpcpy(__dest: *mut c_char,
                  __src: *const c_char)
     -> *mut c_char;
    pub fn __stpncpy(__dest: *mut c_char,
                     __src: *const c_char, __n: size_t)
     -> *mut c_char;
    pub fn stpncpy(__dest: *mut c_char,
                   __src: *const c_char, __n: size_t)
     -> *mut c_char;
    pub fn scm_is_pair(x: SCM) -> c_int;
    pub fn scm_is_string(x: SCM) -> c_int;
    pub fn scm_get_byte_or_eof(port: SCM) -> c_int;
    pub fn scm_peek_byte_or_eof(port: SCM) -> c_int;
    pub fn scm_putc(c: c_char, port: SCM);
    pub fn scm_puts(s: *const c_char, port: SCM);
    pub fn scm_wta(arg: SCM, pos: *const c_char,
                   s_subr: *const c_char) -> SCM;
    pub fn scm_register_module_xxx(module_name: *mut c_char,
                                   init_func: *mut c_void);
    pub fn scm_registered_modules() -> SCM;
    pub fn scm_clear_registered_modules() -> SCM;
    pub fn scm_protect_object(obj: SCM) -> SCM;
    pub fn scm_unprotect_object(obj: SCM) -> SCM;
    pub fn scm_remember(ptr: *mut SCM);
    pub fn scm_make_module(name: SCM) -> SCM;
    pub fn scm_ensure_user_module(name: SCM) -> SCM;
    pub fn scm_load_scheme_module(name: SCM) -> SCM;
    pub fn scm_close_all_ports_except(ports: SCM) -> SCM;
    pub fn scm_makstr(len: size_t, arg1: c_int) -> SCM;
    pub fn scm_makfromstr(src: *const c_char, len: size_t,
                          arg1: c_int) -> SCM;
    pub fn scm_variable_set_name_hint(var: SCM, hint: SCM) -> SCM;
    pub fn scm_builtin_variable(name: SCM) -> SCM;
    pub fn scm_internal_with_fluids(fluids: SCM, vals: SCM,
                                    cproc:
                                        ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                                       *mut c_void)
                                                                  -> SCM>,
                                    cdata: *mut c_void)
     -> SCM;
    pub fn scm_make_gsubr(name: *const c_char,
                          req: c_int,
                          opt: c_int,
                          rst: c_int, fcn: scm_t_subr) -> SCM;
    pub fn scm_make_gsubr_with_generic(name: *const c_char,
                                       req: c_int,
                                       opt: c_int,
                                       rst: c_int,
                                       fcn: scm_t_subr, gf: *mut SCM) -> SCM;
    pub fn scm_create_hook(name: *const c_char,
                           n_args: c_int) -> SCM;
    pub fn scm_internal_dynamic_wind(before: scm_t_guard, inner: scm_t_inner,
                                     after: scm_t_guard,
                                     inner_data: *mut c_void,
                                     guard_data: *mut c_void)
     -> SCM;
    pub fn scm_sloppy_memq(x: SCM, lst: SCM) -> SCM;
    pub fn scm_sloppy_memv(x: SCM, lst: SCM) -> SCM;
    pub fn scm_sloppy_member(x: SCM, lst: SCM) -> SCM;
    pub fn scm_read_and_eval_x(port: SCM) -> SCM;
    pub fn scm_call_catching_errors(thunk: scm_t_subr, err_filter: scm_t_subr,
                                    closure: *mut c_void)
     -> SCM;
    pub fn scm_make_smob_type_mfpe(name: *mut c_char,
                                   size: size_t,
                                   mark:
                                       ::std::option::Option<extern "C" fn(arg1:
                                                                               SCM)
                                                                 -> SCM>,
                                   free:
                                       ::std::option::Option<extern "C" fn(arg1:
                                                                               SCM)
                                                                 -> size_t>,
                                   print:
                                       ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                                      SCM,
                                                                                  arg2:
                                                                                      SCM,
                                                                                  arg3:
                                                                                      *mut scm_print_state)
                                                                 ->
                                                                     c_int>,
                                   equalp:
                                       ::std::option::Option<extern "C" fn(arg1:
                                                                               SCM,
                                                                           arg2:
                                                                               SCM)
                                                                 -> SCM>)
     -> c_long;
    pub fn scm_set_smob_mfpe(tc: c_long,
                             mark:
                                 ::std::option::Option<extern "C" fn(arg1:
                                                                         SCM)
                                                           -> SCM>,
                             free:
                                 ::std::option::Option<extern "C" fn(arg1:
                                                                         SCM)
                                                           -> size_t>,
                             print:
                                 ::std::option::Option<unsafe extern "C" fn(arg1:
                                                                                SCM,
                                                                            arg2:
                                                                                SCM,
                                                                            arg3:
                                                                                *mut scm_print_state)
                                                           ->
                                                               c_int>,
                             equalp:
                                 ::std::option::Option<extern "C" fn(arg1:
                                                                         SCM,
                                                                     arg2:
                                                                         SCM)
                                                           -> SCM>);
    pub fn scm_smob_free(obj: SCM) -> size_t;
    pub fn scm_strprint_obj(obj: SCM) -> SCM;
    pub fn scm_read_0str(expr: *mut c_char) -> SCM;
    pub fn scm_eval_0str(expr: *const c_char) -> SCM;
    pub fn scm_i_object_chars(arg1: SCM) -> *mut c_char;
    pub fn scm_i_object_length(arg1: SCM) -> c_long;
    pub fn scm_sym2ovcell_soft(sym: SCM, obarray: SCM) -> SCM;
    pub fn scm_sym2ovcell(sym: SCM, obarray: SCM) -> SCM;
    pub fn scm_intern_obarray_soft(name: *const c_char,
                                   len: size_t, obarray: SCM,
                                   softness: c_uint) -> SCM;
    pub fn scm_intern_obarray(name: *const c_char,
                              len: size_t, obarray: SCM) -> SCM;
    pub fn scm_symbol_value0(name: *const c_char) -> SCM;
    pub fn scm_string_to_obarray_symbol(o: SCM, s: SCM, softp: SCM) -> SCM;
    pub fn scm_intern_symbol(o: SCM, s: SCM) -> SCM;
    pub fn scm_unintern_symbol(o: SCM, s: SCM) -> SCM;
    pub fn scm_symbol_binding(o: SCM, s: SCM) -> SCM;
    pub fn scm_symbol_bound_p(o: SCM, s: SCM) -> SCM;
    pub fn scm_symbol_set_x(o: SCM, s: SCM, v: SCM) -> SCM;
    pub fn scm_gentemp(prefix: SCM, obarray: SCM) -> SCM;
    pub fn scm_i_makinum(val: scm_t_signed_bits) -> SCM;
    pub fn scm_i_inump(obj: SCM) -> c_int;
    pub fn scm_i_inum(obj: SCM) -> scm_t_signed_bits;
    pub fn scm_c_string2str(obj: SCM, str: *mut c_char,
                            lenp: *mut size_t) -> *mut c_char;
    pub fn scm_c_substring2str(obj: SCM, str: *mut c_char,
                               start: size_t, len: size_t)
     -> *mut c_char;
    pub fn scm_c_symbol2str(obj: SCM, str: *mut c_char,
                            lenp: *mut size_t) -> *mut c_char;
    pub fn scm_truncate(x: c_double)
     -> c_double;
    pub fn scm_round(x: c_double) -> c_double;
    pub fn scm_sys_expt(x: SCM, y: SCM) -> SCM;
    pub fn scm_asinh(x: c_double) -> c_double;
    pub fn scm_acosh(x: c_double) -> c_double;
    pub fn scm_atanh(x: c_double) -> c_double;
    pub fn scm_sys_atan2(z1: SCM, z2: SCM) -> SCM;
    pub fn scm_i_deprecated_symbol_chars(sym: SCM)
     -> *mut c_char;
    pub fn scm_i_deprecated_symbol_length(sym: SCM) -> size_t;
    pub fn scm_i_keywordp(obj: SCM) -> c_int;
    pub fn scm_i_keywordsym(keyword: SCM) -> SCM;
    pub fn scm_i_vectorp(x: SCM) -> c_int;
    pub fn scm_i_vector_length(x: SCM) -> c_ulong;
    pub fn scm_i_velts(x: SCM) -> *const SCM;
    pub fn scm_i_writable_velts(x: SCM) -> *mut SCM;
    pub fn scm_i_vector_ref(x: SCM, idx: size_t) -> SCM;
    pub fn scm_i_vector_set(x: SCM, idx: size_t, val: SCM);
    pub fn scm_vector_equal_p(x: SCM, y: SCM) -> SCM;
    pub fn scm_i_arrayp(a: SCM) -> c_int;
    pub fn scm_i_array_ndim(a: SCM) -> size_t;
    pub fn scm_i_array_contp(a: SCM) -> c_int;
    pub fn scm_i_array_mem(a: SCM) -> *mut scm_t_array;
    pub fn scm_i_array_v(a: SCM) -> SCM;
    pub fn scm_i_array_base(a: SCM) -> size_t;
    pub fn scm_i_array_dims(a: SCM) -> *mut scm_t_array_dim;
    pub fn scm_uniform_array_read_x(ra: SCM, port_or_fd: SCM, start: SCM,
                                    end: SCM) -> SCM;
    pub fn scm_uniform_array_write(v: SCM, port_or_fd: SCM, start: SCM,
                                   end: SCM) -> SCM;
    pub fn scm_i_cur_inp() -> SCM;
    pub fn scm_i_cur_outp() -> SCM;
    pub fn scm_i_cur_errp() -> SCM;
    pub fn scm_i_cur_loadp() -> SCM;
    pub fn scm_i_progargs() -> SCM;
    pub fn scm_i_deprecated_dynwinds() -> SCM;
    pub fn scm_i_stack_base() -> *mut SCM_STACKITEM;
    pub fn scm_i_fluidp(x: SCM) -> c_int;
    pub fn scm_i_defer_ints_etc();
    pub fn scm_i_mask_ints() -> c_int;
    pub fn scm_guard(guardian: SCM, obj: SCM, throw_p: c_int)
     -> SCM;
    pub fn scm_get_one_zombie(guardian: SCM) -> SCM;
    pub fn scm_destroy_guardian_x(guardian: SCM) -> SCM;
    pub fn scm_guardian_greedy_p(guardian: SCM) -> SCM;
    pub fn scm_guardian_destroyed_p(guardian: SCM) -> SCM;
    pub fn scm_trampoline_0(_proc: SCM) -> scm_t_trampoline_0;
    pub fn scm_trampoline_1(_proc: SCM) -> scm_t_trampoline_1;
    pub fn scm_trampoline_2(_proc: SCM) -> scm_t_trampoline_2;
    pub fn scm_i_subr_p(x: SCM) -> c_int;
    pub fn scm_lazy_catch(tag: SCM, thunk: SCM, handler: SCM) -> SCM;
    pub fn scm_internal_lazy_catch(tag: SCM, body: scm_t_catch_body,
                                   body_data: *mut c_void,
                                   handler: scm_t_catch_handler,
                                   handler_data: *mut c_void)
     -> SCM;
    pub fn scm_raequal(ra0: SCM, ra1: SCM) -> SCM;
    pub fn scm_dynamic_args_call(symb: SCM, dobj: SCM, args: SCM) -> SCM;
    pub fn scm_badargsp(formals: SCM, args: SCM) -> c_int;
    pub fn scm_internal_stack_catch(tag: SCM, body: scm_t_catch_body,
                                    body_data: *mut c_void,
                                    handler: scm_t_catch_handler,
                                    handler_data: *mut c_void)
     -> SCM;
    pub fn scm_short2num(n: c_short) -> SCM;
    pub fn scm_ushort2num(n: c_ushort) -> SCM;
    pub fn scm_int2num(n: c_int) -> SCM;
    pub fn scm_uint2num(n: c_uint) -> SCM;
    pub fn scm_long2num(n: c_long) -> SCM;
    pub fn scm_ulong2num(n: c_ulong) -> SCM;
    pub fn scm_size2num(n: size_t) -> SCM;
    pub fn scm_ptrdiff2num(n: scm_t_ptrdiff) -> SCM;
    pub fn scm_num2short(num: SCM, pos: c_ulong,
                         s_caller: *const c_char)
     -> c_short;
    pub fn scm_num2ushort(num: SCM, pos: c_ulong,
                          s_caller: *const c_char)
     -> c_ushort;
    pub fn scm_num2int(num: SCM, pos: c_ulong,
                       s_caller: *const c_char)
     -> c_int;
    pub fn scm_num2uint(num: SCM, pos: c_ulong,
                        s_caller: *const c_char)
     -> c_uint;
    pub fn scm_num2long(num: SCM, pos: c_ulong,
                        s_caller: *const c_char)
     -> c_long;
    pub fn scm_num2ulong(num: SCM, pos: c_ulong,
                         s_caller: *const c_char)
     -> c_ulong;
    pub fn scm_num2ptrdiff(num: SCM, pos: c_ulong,
                           s_caller: *const c_char)
     -> scm_t_ptrdiff;
    pub fn scm_num2size(num: SCM, pos: c_ulong,
                        s_caller: *const c_char) -> size_t;
    pub fn scm_long_long2num(sl: c_longlong) -> SCM;
    pub fn scm_ulong_long2num(sl: c_ulonglong) -> SCM;
    pub fn scm_num2long_long(num: SCM, pos: c_ulong,
                             s_caller: *const c_char)
     -> c_longlong;
    pub fn scm_num2ulong_long(num: SCM, pos: c_ulong,
                              s_caller: *const c_char)
     -> c_ulonglong;
    pub fn scm_make_real(x: c_double) -> SCM;
    pub fn scm_num2dbl(a: SCM, why: *const c_char)
     -> c_double;
    pub fn scm_float2num(n: c_float) -> SCM;
    pub fn scm_double2num(n: c_double) -> SCM;
    pub fn scm_num2float(num: SCM, pos: c_ulong,
                         s_caller: *const c_char)
     -> c_float;
    pub fn scm_num2double(num: SCM, pos: c_ulong,
                          s_caller: *const c_char)
     -> c_double;
    pub fn scm_make_complex(x: c_double,
                            y: c_double) -> SCM;
    pub fn scm_mem2symbol(mem: *const c_char, len: size_t)
     -> SCM;
    pub fn scm_mem2uninterned_symbol(mem: *const c_char,
                                     len: size_t) -> SCM;
    pub fn scm_str2symbol(str: *const c_char) -> SCM;
    pub fn scm_take_str(s: *mut c_char, len: size_t) -> SCM;
    pub fn scm_take0str(s: *mut c_char) -> SCM;
    pub fn scm_mem2string(src: *const c_char, len: size_t)
     -> SCM;
    pub fn scm_str2string(src: *const c_char) -> SCM;
    pub fn scm_makfrom0str(src: *const c_char) -> SCM;
    pub fn scm_makfrom0str_opt(src: *const c_char) -> SCM;
    pub fn scm_allocate_string(len: size_t) -> SCM;
    pub fn scm_make_keyword_from_dash_symbol(symbol: SCM) -> SCM;
    pub fn scm_keyword_dash_symbol(keyword: SCM) -> SCM;
    pub fn scm_c_make_keyword(s: *const c_char) -> SCM;
    pub fn scm_thread_sleep(arg1: c_uint)
     -> c_uint;
    pub fn scm_thread_usleep(arg1: c_ulong)
     -> c_ulong;
    pub fn scm_internal_select(fds: c_int, rfds: *mut fd_set,
                               wfds: *mut fd_set, efds: *mut fd_set,
                               timeout: *mut Struct_timeval)
     -> c_int;
    pub fn scm_cuserid() -> SCM;
    pub fn scm_primitive_make_property(not_found_proc: SCM) -> SCM;
    pub fn scm_primitive_property_ref(prop: SCM, obj: SCM) -> SCM;
    pub fn scm_primitive_property_set_x(prop: SCM, obj: SCM, val: SCM) -> SCM;
    pub fn scm_primitive_property_del_x(prop: SCM, obj: SCM) -> SCM;
    pub fn scm_whash_get_handle(whash: SCM, key: SCM) -> SCM;
    pub fn SCM_WHASHFOUNDP(h: SCM) -> c_int;
    pub fn SCM_WHASHREF(whash: SCM, handle: SCM) -> SCM;
    pub fn SCM_WHASHSET(whash: SCM, handle: SCM, obj: SCM);
    pub fn scm_whash_create_handle(whash: SCM, key: SCM) -> SCM;
    pub fn scm_whash_lookup(whash: SCM, obj: SCM) -> SCM;
    pub fn scm_whash_insert(whash: SCM, key: SCM, obj: SCM);
    pub fn scm_struct_create_handle(obj: SCM) -> SCM;
    pub fn scm_immutable_cell(car: scm_t_bits, cdr: scm_t_bits) -> SCM;
    pub fn scm_immutable_double_cell(car: scm_t_bits, cbr: scm_t_bits,
                                     ccr: scm_t_bits, cdr: scm_t_bits) -> SCM;
    pub fn scm_i_deprecated_asrtgo(condition: scm_t_bits) -> scm_t_bits;
    pub fn scm_sym2var(sym: SCM, thunk: SCM, definep: SCM) -> SCM;
    pub fn scm_lookup_closure_module(_proc: SCM) -> SCM;
    pub fn scm_module_lookup_closure(module: SCM) -> SCM;
    pub fn scm_current_module_lookup_closure() -> SCM;
    pub fn scm_eval_closure_lookup(eclo: SCM, sym: SCM, definep: SCM) -> SCM;
    pub fn scm_standard_eval_closure(module: SCM) -> SCM;
    pub fn scm_standard_interface_eval_closure(module: SCM) -> SCM;
    pub fn scm_eval_closure_module(eval_closure: SCM) -> SCM;
    pub fn scm_struct_vtable_tag(handle: SCM) -> SCM;
    pub fn scm_generalized_vector_p(v: SCM) -> SCM;
    pub fn scm_generalized_vector_length(v: SCM) -> SCM;
    pub fn scm_generalized_vector_ref(v: SCM, idx: SCM) -> SCM;
    pub fn scm_generalized_vector_set_x(v: SCM, idx: SCM, val: SCM) -> SCM;
    pub fn scm_generalized_vector_to_list(v: SCM) -> SCM;
    pub fn scm_c_program_source(program: SCM, ip: size_t) -> SCM;
    pub fn scm_gc_live_object_stats() -> SCM;
    pub fn scm_htons(_in: SCM) -> SCM;
    pub fn scm_ntohs(_in: SCM) -> SCM;
    pub fn scm_htonl(_in: SCM) -> SCM;
    pub fn scm_ntohl(_in: SCM) -> SCM;
    pub fn scm_i_init_deprecated();
}