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

#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage, Align> {
    storage: Storage,
    align: [Align; 0],
}
impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
    #[inline]
    pub const fn new(storage: Storage) -> Self {
        Self { storage, align: [] }
    }
}
impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
where
    Storage: AsRef<[u8]> + AsMut<[u8]>,
{
    #[inline]
    pub fn get_bit(&self, index: usize) -> bool {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = self.storage.as_ref()[byte_index];
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        byte & mask == mask
    }
    #[inline]
    pub fn set_bit(&mut self, index: usize, val: bool) {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = &mut self.storage.as_mut()[byte_index];
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        if val {
            *byte |= mask;
        } else {
            *byte &= !mask;
        }
    }
    #[inline]
    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
        let mut val = 0;
        for i in 0..(bit_width as usize) {
            if self.get_bit(i + bit_offset) {
                let index = if cfg!(target_endian = "big") {
                    bit_width as usize - 1 - i
                } else {
                    i
                };
                val |= 1 << index;
            }
        }
        val
    }
    #[inline]
    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
        for i in 0..(bit_width as usize) {
            let mask = 1 << i;
            let val_bit_is_set = val & mask == mask;
            let index = if cfg!(target_endian = "big") {
                bit_width as usize - 1 - i
            } else {
                i
            };
            self.set_bit(index + bit_offset, val_bit_is_set);
        }
    }
}
pub const VIPS_PI: f64 = 3.141592653589793;
pub const VIPS_PATH_MAX: u32 = 4096;
pub const VIPS_VERSION: &'static [u8; 6usize] = b"8.8.3\0";
pub const VIPS_VERSION_STRING: &'static [u8; 35usize] = b"8.8.3-Tue Sep 17 15:26:14 UTC 2019\0";
pub const VIPS_MAJOR_VERSION: u32 = 8;
pub const VIPS_MINOR_VERSION: u32 = 8;
pub const VIPS_MICRO_VERSION: u32 = 3;
pub const VIPS_LIBRARY_CURRENT: u32 = 53;
pub const VIPS_LIBRARY_REVISION: u32 = 2;
pub const VIPS_LIBRARY_AGE: u32 = 11;
pub const VIPS_SONAME: &'static [u8; 14usize] = b"libvips.so.42\0";
pub const VIPS_EXEEXT: &'static [u8; 1usize] = b"\0";
pub const VIPS_ENABLE_DEPRECATED: u32 = 1;
pub const VIPS_SPARE: u32 = 8;
pub const VIPS__WINDOW_MARGIN_PIXELS: u32 = 128;
pub const VIPS__WINDOW_MARGIN_BYTES: u32 = 10485760;
pub const VIPS_SIZEOF_HEADER: u32 = 64;
pub const VIPS__TILE_WIDTH: u32 = 128;
pub const VIPS__TILE_HEIGHT: u32 = 128;
pub const VIPS__THINSTRIP_HEIGHT: u32 = 1;
pub const VIPS__FATSTRIP_HEIGHT: u32 = 16;
pub const VIPS_MAGIC_INTEL: u32 = 3064394248;
pub const VIPS_MAGIC_SPARC: u32 = 150120118;
pub const VIPS_MAX_COORD: u32 = 10000000;
pub const VIPS_TRANSFORM_SHIFT: u32 = 6;
pub const VIPS_TRANSFORM_SCALE: u32 = 64;
pub const VIPS_INTERPOLATE_SHIFT: u32 = 12;
pub const VIPS_INTERPOLATE_SCALE: u32 = 4096;
pub const VIPS_META_EXIF_NAME: &'static [u8; 10usize] = b"exif-data\0";
pub const VIPS_META_XMP_NAME: &'static [u8; 9usize] = b"xmp-data\0";
pub const VIPS_META_IPTC_NAME: &'static [u8; 10usize] = b"iptc-data\0";
pub const VIPS_META_PHOTOSHOP_NAME: &'static [u8; 15usize] = b"photoshop-data\0";
pub const VIPS_META_ICC_NAME: &'static [u8; 17usize] = b"icc-profile-data\0";
pub const VIPS_META_IMAGEDESCRIPTION: &'static [u8; 18usize] = b"image-description\0";
pub const VIPS_META_RESOLUTION_UNIT: &'static [u8; 16usize] = b"resolution-unit\0";
pub const VIPS_META_LOADER: &'static [u8; 12usize] = b"vips-loader\0";
pub const VIPS_META_SEQUENTIAL: &'static [u8; 16usize] = b"vips-sequential\0";
pub const VIPS_META_ORIENTATION: &'static [u8; 12usize] = b"orientation\0";
pub const VIPS_META_PAGE_HEIGHT: &'static [u8; 12usize] = b"page-height\0";
pub const VIPS_META_N_PAGES: &'static [u8; 8usize] = b"n-pages\0";
pub const VIPS_D93_X0: f64 = 89.74;
pub const VIPS_D93_Y0: f64 = 100.0;
pub const VIPS_D93_Z0: f64 = 130.77;
pub const VIPS_D75_X0: f64 = 94.9682;
pub const VIPS_D75_Y0: f64 = 100.0;
pub const VIPS_D75_Z0: f64 = 122.571;
pub const VIPS_D65_X0: f64 = 95.047;
pub const VIPS_D65_Y0: f64 = 100.0;
pub const VIPS_D65_Z0: f64 = 108.8827;
pub const VIPS_D55_X0: f64 = 95.6831;
pub const VIPS_D55_Y0: f64 = 100.0;
pub const VIPS_D55_Z0: f64 = 92.0871;
pub const VIPS_D50_X0: f64 = 96.425;
pub const VIPS_D50_Y0: f64 = 100.0;
pub const VIPS_D50_Z0: f64 = 82.468;
pub const VIPS_A_X0: f64 = 109.8503;
pub const VIPS_A_Y0: f64 = 100.0;
pub const VIPS_A_Z0: f64 = 35.5849;
pub const VIPS_B_X0: f64 = 99.072;
pub const VIPS_B_Y0: f64 = 100.0;
pub const VIPS_B_Z0: f64 = 85.223;
pub const VIPS_C_X0: f64 = 98.07;
pub const VIPS_C_Y0: f64 = 100.0;
pub const VIPS_C_Z0: f64 = 118.23;
pub const VIPS_E_X0: f64 = 100.0;
pub const VIPS_E_Y0: f64 = 100.0;
pub const VIPS_E_Z0: f64 = 100.0;
pub const VIPS_D3250_X0: f64 = 105.659;
pub const VIPS_D3250_Y0: f64 = 100.0;
pub const VIPS_D3250_Z0: f64 = 45.8501;
pub type guint32 = ::std::os::raw::c_uint;
pub type gint64 = ::std::os::raw::c_long;
pub type guint64 = ::std::os::raw::c_ulong;
pub type gsize = ::std::os::raw::c_ulong;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
pub type gchar = ::std::os::raw::c_char;
pub type glong = ::std::os::raw::c_long;
pub type gint = ::std::os::raw::c_int;
pub type gboolean = gint;
pub type gulong = ::std::os::raw::c_ulong;
pub type guint = ::std::os::raw::c_uint;
pub type gfloat = f32;
pub type gdouble = f64;
pub type gpointer = *mut ::std::os::raw::c_void;
pub type GDestroyNotify = ::std::option::Option<unsafe extern "C" fn(data: gpointer)>;
pub type va_list = __builtin_va_list;
pub type GQuark = guint32;
pub type GError = _GError;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GError {
    pub domain: GQuark,
    pub code: gint,
    pub message: *mut gchar,
}
#[test]
fn bindgen_test_layout__GError() {
    assert_eq!(
        ::std::mem::size_of::<_GError>(),
        16usize,
        concat!("Size of: ", stringify!(_GError))
    );
    assert_eq!(
        ::std::mem::align_of::<_GError>(),
        8usize,
        concat!("Alignment of ", stringify!(_GError))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GError>())).domain as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GError),
            "::",
            stringify!(domain)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GError>())).code as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(_GError),
            "::",
            stringify!(code)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GError>())).message as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_GError),
            "::",
            stringify!(message)
        )
    );
}
pub type off_t = __off_t;
pub type GThreadFunc = ::std::option::Option<unsafe extern "C" fn(data: gpointer) -> gpointer>;
pub type GThread = _GThread;
pub type GMutex = _GMutex;
pub type GCond = _GCond;
#[repr(C)]
#[derive(Copy, Clone)]
pub union _GMutex {
    pub p: gpointer,
    pub i: [guint; 2usize],
    _bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout__GMutex() {
    assert_eq!(
        ::std::mem::size_of::<_GMutex>(),
        8usize,
        concat!("Size of: ", stringify!(_GMutex))
    );
    assert_eq!(
        ::std::mem::align_of::<_GMutex>(),
        8usize,
        concat!("Alignment of ", stringify!(_GMutex))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GMutex>())).p as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GMutex),
            "::",
            stringify!(p)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GMutex>())).i as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GMutex),
            "::",
            stringify!(i)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GCond {
    pub p: gpointer,
    pub i: [guint; 2usize],
}
#[test]
fn bindgen_test_layout__GCond() {
    assert_eq!(
        ::std::mem::size_of::<_GCond>(),
        16usize,
        concat!("Size of: ", stringify!(_GCond))
    );
    assert_eq!(
        ::std::mem::align_of::<_GCond>(),
        8usize,
        concat!("Alignment of ", stringify!(_GCond))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GCond>())).p as *const _ as usize },
        0usize,
        concat!("Offset of field: ", stringify!(_GCond), "::", stringify!(p))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GCond>())).i as *const _ as usize },
        8usize,
        concat!("Offset of field: ", stringify!(_GCond), "::", stringify!(i))
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GData {
    _unused: [u8; 0],
}
pub type GData = _GData;
pub type GDuplicateFunc =
    ::std::option::Option<unsafe extern "C" fn(data: gpointer, user_data: gpointer) -> gpointer>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GHashTable {
    _unused: [u8; 0],
}
pub type GHashTable = _GHashTable;
pub type GSList = _GSList;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GSList {
    pub data: gpointer,
    pub next: *mut GSList,
}
#[test]
fn bindgen_test_layout__GSList() {
    assert_eq!(
        ::std::mem::size_of::<_GSList>(),
        16usize,
        concat!("Size of: ", stringify!(_GSList))
    );
    assert_eq!(
        ::std::mem::align_of::<_GSList>(),
        8usize,
        concat!("Alignment of ", stringify!(_GSList))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GSList>())).data as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GSList),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GSList>())).next as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_GSList),
            "::",
            stringify!(next)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GOptionGroup {
    _unused: [u8; 0],
}
pub type GOptionGroup = _GOptionGroup;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GTimer {
    _unused: [u8; 0],
}
pub type GTimer = _GTimer;
pub const GThreadPriority_G_THREAD_PRIORITY_LOW: GThreadPriority = 0;
pub const GThreadPriority_G_THREAD_PRIORITY_NORMAL: GThreadPriority = 1;
pub const GThreadPriority_G_THREAD_PRIORITY_HIGH: GThreadPriority = 2;
pub const GThreadPriority_G_THREAD_PRIORITY_URGENT: GThreadPriority = 3;
pub type GThreadPriority = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GThread {
    pub func: GThreadFunc,
    pub data: gpointer,
    pub joinable: gboolean,
    pub priority: GThreadPriority,
}
#[test]
fn bindgen_test_layout__GThread() {
    assert_eq!(
        ::std::mem::size_of::<_GThread>(),
        24usize,
        concat!("Size of: ", stringify!(_GThread))
    );
    assert_eq!(
        ::std::mem::align_of::<_GThread>(),
        8usize,
        concat!("Alignment of ", stringify!(_GThread))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GThread>())).func as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GThread),
            "::",
            stringify!(func)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GThread>())).data as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_GThread),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GThread>())).joinable as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_GThread),
            "::",
            stringify!(joinable)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GThread>())).priority as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(_GThread),
            "::",
            stringify!(priority)
        )
    );
}
pub type FILE = _IO_FILE;
pub type _IO_lock_t = ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_marker {
    pub _next: *mut _IO_marker,
    pub _sbuf: *mut _IO_FILE,
    pub _pos: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__IO_marker() {
    assert_eq!(
        ::std::mem::size_of::<_IO_marker>(),
        24usize,
        concat!("Size of: ", stringify!(_IO_marker))
    );
    assert_eq!(
        ::std::mem::align_of::<_IO_marker>(),
        8usize,
        concat!("Alignment of ", stringify!(_IO_marker))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_marker>()))._next as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_marker),
            "::",
            stringify!(_next)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_marker>()))._sbuf as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_marker),
            "::",
            stringify!(_sbuf)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_marker>()))._pos as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_marker),
            "::",
            stringify!(_pos)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_FILE {
    pub _flags: ::std::os::raw::c_int,
    pub _IO_read_ptr: *mut ::std::os::raw::c_char,
    pub _IO_read_end: *mut ::std::os::raw::c_char,
    pub _IO_read_base: *mut ::std::os::raw::c_char,
    pub _IO_write_base: *mut ::std::os::raw::c_char,
    pub _IO_write_ptr: *mut ::std::os::raw::c_char,
    pub _IO_write_end: *mut ::std::os::raw::c_char,
    pub _IO_buf_base: *mut ::std::os::raw::c_char,
    pub _IO_buf_end: *mut ::std::os::raw::c_char,
    pub _IO_save_base: *mut ::std::os::raw::c_char,
    pub _IO_backup_base: *mut ::std::os::raw::c_char,
    pub _IO_save_end: *mut ::std::os::raw::c_char,
    pub _markers: *mut _IO_marker,
    pub _chain: *mut _IO_FILE,
    pub _fileno: ::std::os::raw::c_int,
    pub _flags2: ::std::os::raw::c_int,
    pub _old_offset: __off_t,
    pub _cur_column: ::std::os::raw::c_ushort,
    pub _vtable_offset: ::std::os::raw::c_schar,
    pub _shortbuf: [::std::os::raw::c_char; 1usize],
    pub _lock: *mut _IO_lock_t,
    pub _offset: __off64_t,
    pub __pad1: *mut ::std::os::raw::c_void,
    pub __pad2: *mut ::std::os::raw::c_void,
    pub __pad3: *mut ::std::os::raw::c_void,
    pub __pad4: *mut ::std::os::raw::c_void,
    pub __pad5: usize,
    pub _mode: ::std::os::raw::c_int,
    pub _unused2: [::std::os::raw::c_char; 20usize],
}
#[test]
fn bindgen_test_layout__IO_FILE() {
    assert_eq!(
        ::std::mem::size_of::<_IO_FILE>(),
        216usize,
        concat!("Size of: ", stringify!(_IO_FILE))
    );
    assert_eq!(
        ::std::mem::align_of::<_IO_FILE>(),
        8usize,
        concat!("Alignment of ", stringify!(_IO_FILE))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_ptr as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_read_ptr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_end as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_read_end)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_base as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_read_base)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_base as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_write_base)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_ptr as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_write_ptr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_end as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_write_end)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_base as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_buf_base)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_end as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_buf_end)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_base as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_save_base)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_backup_base as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_backup_base)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_end as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_IO_save_end)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._markers as *const _ as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_markers)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._chain as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_chain)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._fileno as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_fileno)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags2 as *const _ as usize },
        116usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_flags2)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._old_offset as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_old_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._cur_column as *const _ as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_cur_column)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._vtable_offset as *const _ as usize },
        130usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_vtable_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._shortbuf as *const _ as usize },
        131usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_shortbuf)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._lock as *const _ as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_lock)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._offset as *const _ as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad1 as *const _ as usize },
        152usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(__pad1)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad2 as *const _ as usize },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(__pad2)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad3 as *const _ as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(__pad3)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad4 as *const _ as usize },
        176usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(__pad4)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad5 as *const _ as usize },
        184usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(__pad5)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._mode as *const _ as usize },
        192usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_mode)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._unused2 as *const _ as usize },
        196usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_unused2)
        )
    );
}
pub type GType = gsize;
pub type GValue = _GValue;
pub type GTypeClass = _GTypeClass;
pub type GTypeInstance = _GTypeInstance;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GTypeClass {
    pub g_type: GType,
}
#[test]
fn bindgen_test_layout__GTypeClass() {
    assert_eq!(
        ::std::mem::size_of::<_GTypeClass>(),
        8usize,
        concat!("Size of: ", stringify!(_GTypeClass))
    );
    assert_eq!(
        ::std::mem::align_of::<_GTypeClass>(),
        8usize,
        concat!("Alignment of ", stringify!(_GTypeClass))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GTypeClass>())).g_type as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GTypeClass),
            "::",
            stringify!(g_type)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GTypeInstance {
    pub g_class: *mut GTypeClass,
}
#[test]
fn bindgen_test_layout__GTypeInstance() {
    assert_eq!(
        ::std::mem::size_of::<_GTypeInstance>(),
        8usize,
        concat!("Size of: ", stringify!(_GTypeInstance))
    );
    assert_eq!(
        ::std::mem::align_of::<_GTypeInstance>(),
        8usize,
        concat!("Alignment of ", stringify!(_GTypeInstance))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GTypeInstance>())).g_class as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GTypeInstance),
            "::",
            stringify!(g_class)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _GValue {
    pub g_type: GType,
    pub data: [_GValue__bindgen_ty_1; 2usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _GValue__bindgen_ty_1 {
    pub v_int: gint,
    pub v_uint: guint,
    pub v_long: glong,
    pub v_ulong: gulong,
    pub v_int64: gint64,
    pub v_uint64: guint64,
    pub v_float: gfloat,
    pub v_double: gdouble,
    pub v_pointer: gpointer,
    _bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout__GValue__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<_GValue__bindgen_ty_1>(),
        8usize,
        concat!("Size of: ", stringify!(_GValue__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<_GValue__bindgen_ty_1>(),
        8usize,
        concat!("Alignment of ", stringify!(_GValue__bindgen_ty_1))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue__bindgen_ty_1>())).v_int as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue__bindgen_ty_1),
            "::",
            stringify!(v_int)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue__bindgen_ty_1>())).v_uint as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue__bindgen_ty_1),
            "::",
            stringify!(v_uint)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue__bindgen_ty_1>())).v_long as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue__bindgen_ty_1),
            "::",
            stringify!(v_long)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue__bindgen_ty_1>())).v_ulong as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue__bindgen_ty_1),
            "::",
            stringify!(v_ulong)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue__bindgen_ty_1>())).v_int64 as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue__bindgen_ty_1),
            "::",
            stringify!(v_int64)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue__bindgen_ty_1>())).v_uint64 as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue__bindgen_ty_1),
            "::",
            stringify!(v_uint64)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue__bindgen_ty_1>())).v_float as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue__bindgen_ty_1),
            "::",
            stringify!(v_float)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue__bindgen_ty_1>())).v_double as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue__bindgen_ty_1),
            "::",
            stringify!(v_double)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue__bindgen_ty_1>())).v_pointer as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue__bindgen_ty_1),
            "::",
            stringify!(v_pointer)
        )
    );
}
#[test]
fn bindgen_test_layout__GValue() {
    assert_eq!(
        ::std::mem::size_of::<_GValue>(),
        24usize,
        concat!("Size of: ", stringify!(_GValue))
    );
    assert_eq!(
        ::std::mem::align_of::<_GValue>(),
        8usize,
        concat!("Alignment of ", stringify!(_GValue))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue>())).g_type as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue),
            "::",
            stringify!(g_type)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue>())).data as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue),
            "::",
            stringify!(data)
        )
    );
}
pub const GParamFlags_G_PARAM_READABLE: GParamFlags = 1;
pub const GParamFlags_G_PARAM_WRITABLE: GParamFlags = 2;
pub const GParamFlags_G_PARAM_READWRITE: GParamFlags = 3;
pub const GParamFlags_G_PARAM_CONSTRUCT: GParamFlags = 4;
pub const GParamFlags_G_PARAM_CONSTRUCT_ONLY: GParamFlags = 8;
pub const GParamFlags_G_PARAM_LAX_VALIDATION: GParamFlags = 16;
pub const GParamFlags_G_PARAM_STATIC_NAME: GParamFlags = 32;
pub const GParamFlags_G_PARAM_PRIVATE: GParamFlags = 32;
pub const GParamFlags_G_PARAM_STATIC_NICK: GParamFlags = 64;
pub const GParamFlags_G_PARAM_STATIC_BLURB: GParamFlags = 128;
pub const GParamFlags_G_PARAM_EXPLICIT_NOTIFY: GParamFlags = 1073741824;
pub const GParamFlags_G_PARAM_DEPRECATED: GParamFlags = -2147483648;
pub type GParamFlags = i32;
pub type GParamSpec = _GParamSpec;
pub type GParameter = _GParameter;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GParamSpec {
    pub g_type_instance: GTypeInstance,
    pub name: *const gchar,
    pub flags: GParamFlags,
    pub value_type: GType,
    pub owner_type: GType,
    pub _nick: *mut gchar,
    pub _blurb: *mut gchar,
    pub qdata: *mut GData,
    pub ref_count: guint,
    pub param_id: guint,
}
#[test]
fn bindgen_test_layout__GParamSpec() {
    assert_eq!(
        ::std::mem::size_of::<_GParamSpec>(),
        72usize,
        concat!("Size of: ", stringify!(_GParamSpec))
    );
    assert_eq!(
        ::std::mem::align_of::<_GParamSpec>(),
        8usize,
        concat!("Alignment of ", stringify!(_GParamSpec))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParamSpec>())).g_type_instance as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParamSpec),
            "::",
            stringify!(g_type_instance)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParamSpec>())).name as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParamSpec),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParamSpec>())).flags as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParamSpec),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParamSpec>())).value_type as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParamSpec),
            "::",
            stringify!(value_type)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParamSpec>())).owner_type as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParamSpec),
            "::",
            stringify!(owner_type)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParamSpec>()))._nick as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParamSpec),
            "::",
            stringify!(_nick)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParamSpec>()))._blurb as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParamSpec),
            "::",
            stringify!(_blurb)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParamSpec>())).qdata as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParamSpec),
            "::",
            stringify!(qdata)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParamSpec>())).ref_count as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParamSpec),
            "::",
            stringify!(ref_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParamSpec>())).param_id as *const _ as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParamSpec),
            "::",
            stringify!(param_id)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _GParameter {
    pub name: *const gchar,
    pub value: GValue,
}
#[test]
fn bindgen_test_layout__GParameter() {
    assert_eq!(
        ::std::mem::size_of::<_GParameter>(),
        32usize,
        concat!("Size of: ", stringify!(_GParameter))
    );
    assert_eq!(
        ::std::mem::align_of::<_GParameter>(),
        8usize,
        concat!("Alignment of ", stringify!(_GParameter))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParameter>())).name as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParameter),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParameter>())).value as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParameter),
            "::",
            stringify!(value)
        )
    );
}
pub type GClosure = _GClosure;
pub type GClosureNotifyData = _GClosureNotifyData;
pub type GClosureNotify =
    ::std::option::Option<unsafe extern "C" fn(data: gpointer, closure: *mut GClosure)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GClosureNotifyData {
    pub data: gpointer,
    pub notify: GClosureNotify,
}
#[test]
fn bindgen_test_layout__GClosureNotifyData() {
    assert_eq!(
        ::std::mem::size_of::<_GClosureNotifyData>(),
        16usize,
        concat!("Size of: ", stringify!(_GClosureNotifyData))
    );
    assert_eq!(
        ::std::mem::align_of::<_GClosureNotifyData>(),
        8usize,
        concat!("Alignment of ", stringify!(_GClosureNotifyData))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GClosureNotifyData>())).data as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GClosureNotifyData),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GClosureNotifyData>())).notify as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_GClosureNotifyData),
            "::",
            stringify!(notify)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GClosure {
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u16>,
    pub marshal: ::std::option::Option<
        unsafe extern "C" fn(
            closure: *mut GClosure,
            return_value: *mut GValue,
            n_param_values: guint,
            param_values: *const GValue,
            invocation_hint: gpointer,
            marshal_data: gpointer,
        ),
    >,
    pub data: gpointer,
    pub notifiers: *mut GClosureNotifyData,
}
#[test]
fn bindgen_test_layout__GClosure() {
    assert_eq!(
        ::std::mem::size_of::<_GClosure>(),
        32usize,
        concat!("Size of: ", stringify!(_GClosure))
    );
    assert_eq!(
        ::std::mem::align_of::<_GClosure>(),
        8usize,
        concat!("Alignment of ", stringify!(_GClosure))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GClosure>())).marshal as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_GClosure),
            "::",
            stringify!(marshal)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GClosure>())).data as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_GClosure),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GClosure>())).notifiers as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_GClosure),
            "::",
            stringify!(notifiers)
        )
    );
}
impl _GClosure {
    #[inline]
    pub fn ref_count(&self) -> guint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 15u8) as u32) }
    }
    #[inline]
    pub fn set_ref_count(&mut self, val: guint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 15u8, val as u64)
        }
    }
    #[inline]
    pub fn meta_marshal_nouse(&self) -> guint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_meta_marshal_nouse(&mut self, val: guint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(15usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn n_guards(&self) -> guint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_n_guards(&mut self, val: guint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(16usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn n_fnotifiers(&self) -> guint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u32) }
    }
    #[inline]
    pub fn set_n_fnotifiers(&mut self, val: guint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(17usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub fn n_inotifiers(&self) -> guint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_n_inotifiers(&mut self, val: guint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(19usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub fn in_inotify(&self) -> guint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_in_inotify(&mut self, val: guint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(27usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn floating(&self) -> guint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_floating(&mut self, val: guint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(28usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn derivative_flag(&self) -> guint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_derivative_flag(&mut self, val: guint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(29usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn in_marshal(&self) -> guint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_in_marshal(&mut self, val: guint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(30usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn is_invalid(&self) -> guint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_is_invalid(&mut self, val: guint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(31usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        ref_count: guint,
        meta_marshal_nouse: guint,
        n_guards: guint,
        n_fnotifiers: guint,
        n_inotifiers: guint,
        in_inotify: guint,
        floating: guint,
        derivative_flag: guint,
        in_marshal: guint,
        is_invalid: guint,
    ) -> __BindgenBitfieldUnit<[u8; 4usize], u16> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u16> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 15u8, {
            let ref_count: u32 = unsafe { ::std::mem::transmute(ref_count) };
            ref_count as u64
        });
        __bindgen_bitfield_unit.set(15usize, 1u8, {
            let meta_marshal_nouse: u32 = unsafe { ::std::mem::transmute(meta_marshal_nouse) };
            meta_marshal_nouse as u64
        });
        __bindgen_bitfield_unit.set(16usize, 1u8, {
            let n_guards: u32 = unsafe { ::std::mem::transmute(n_guards) };
            n_guards as u64
        });
        __bindgen_bitfield_unit.set(17usize, 2u8, {
            let n_fnotifiers: u32 = unsafe { ::std::mem::transmute(n_fnotifiers) };
            n_fnotifiers as u64
        });
        __bindgen_bitfield_unit.set(19usize, 8u8, {
            let n_inotifiers: u32 = unsafe { ::std::mem::transmute(n_inotifiers) };
            n_inotifiers as u64
        });
        __bindgen_bitfield_unit.set(27usize, 1u8, {
            let in_inotify: u32 = unsafe { ::std::mem::transmute(in_inotify) };
            in_inotify as u64
        });
        __bindgen_bitfield_unit.set(28usize, 1u8, {
            let floating: u32 = unsafe { ::std::mem::transmute(floating) };
            floating as u64
        });
        __bindgen_bitfield_unit.set(29usize, 1u8, {
            let derivative_flag: u32 = unsafe { ::std::mem::transmute(derivative_flag) };
            derivative_flag as u64
        });
        __bindgen_bitfield_unit.set(30usize, 1u8, {
            let in_marshal: u32 = unsafe { ::std::mem::transmute(in_marshal) };
            in_marshal as u64
        });
        __bindgen_bitfield_unit.set(31usize, 1u8, {
            let is_invalid: u32 = unsafe { ::std::mem::transmute(is_invalid) };
            is_invalid as u64
        });
        __bindgen_bitfield_unit
    }
}
pub type GObject = _GObject;
pub type GObjectClass = _GObjectClass;
pub type GObjectConstructParam = _GObjectConstructParam;
pub type GWeakNotify =
    ::std::option::Option<unsafe extern "C" fn(data: gpointer, where_the_object_was: *mut GObject)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GObject {
    pub g_type_instance: GTypeInstance,
    pub ref_count: guint,
    pub qdata: *mut GData,
}
#[test]
fn bindgen_test_layout__GObject() {
    assert_eq!(
        ::std::mem::size_of::<_GObject>(),
        24usize,
        concat!("Size of: ", stringify!(_GObject))
    );
    assert_eq!(
        ::std::mem::align_of::<_GObject>(),
        8usize,
        concat!("Alignment of ", stringify!(_GObject))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObject>())).g_type_instance as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObject),
            "::",
            stringify!(g_type_instance)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObject>())).ref_count as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObject),
            "::",
            stringify!(ref_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObject>())).qdata as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObject),
            "::",
            stringify!(qdata)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GObjectClass {
    pub g_type_class: GTypeClass,
    pub construct_properties: *mut GSList,
    pub constructor: ::std::option::Option<
        unsafe extern "C" fn(
            type_: GType,
            n_construct_properties: guint,
            construct_properties: *mut GObjectConstructParam,
        ) -> *mut GObject,
    >,
    pub set_property: ::std::option::Option<
        unsafe extern "C" fn(
            object: *mut GObject,
            property_id: guint,
            value: *const GValue,
            pspec: *mut GParamSpec,
        ),
    >,
    pub get_property: ::std::option::Option<
        unsafe extern "C" fn(
            object: *mut GObject,
            property_id: guint,
            value: *mut GValue,
            pspec: *mut GParamSpec,
        ),
    >,
    pub dispose: ::std::option::Option<unsafe extern "C" fn(object: *mut GObject)>,
    pub finalize: ::std::option::Option<unsafe extern "C" fn(object: *mut GObject)>,
    pub dispatch_properties_changed: ::std::option::Option<
        unsafe extern "C" fn(object: *mut GObject, n_pspecs: guint, pspecs: *mut *mut GParamSpec),
    >,
    pub notify:
        ::std::option::Option<unsafe extern "C" fn(object: *mut GObject, pspec: *mut GParamSpec)>,
    pub constructed: ::std::option::Option<unsafe extern "C" fn(object: *mut GObject)>,
    pub flags: gsize,
    pub pdummy: [gpointer; 6usize],
}
#[test]
fn bindgen_test_layout__GObjectClass() {
    assert_eq!(
        ::std::mem::size_of::<_GObjectClass>(),
        136usize,
        concat!("Size of: ", stringify!(_GObjectClass))
    );
    assert_eq!(
        ::std::mem::align_of::<_GObjectClass>(),
        8usize,
        concat!("Alignment of ", stringify!(_GObjectClass))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectClass>())).g_type_class as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(g_type_class)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_GObjectClass>())).construct_properties as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(construct_properties)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectClass>())).constructor as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(constructor)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectClass>())).set_property as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(set_property)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectClass>())).get_property as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(get_property)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectClass>())).dispose as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(dispose)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectClass>())).finalize as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(finalize)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_GObjectClass>())).dispatch_properties_changed as *const _
                as usize
        },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(dispatch_properties_changed)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectClass>())).notify as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(notify)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectClass>())).constructed as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(constructed)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectClass>())).flags as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectClass>())).pdummy as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(pdummy)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GObjectConstructParam {
    pub pspec: *mut GParamSpec,
    pub value: *mut GValue,
}
#[test]
fn bindgen_test_layout__GObjectConstructParam() {
    assert_eq!(
        ::std::mem::size_of::<_GObjectConstructParam>(),
        16usize,
        concat!("Size of: ", stringify!(_GObjectConstructParam))
    );
    assert_eq!(
        ::std::mem::align_of::<_GObjectConstructParam>(),
        8usize,
        concat!("Alignment of ", stringify!(_GObjectConstructParam))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectConstructParam>())).pspec as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectConstructParam),
            "::",
            stringify!(pspec)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectConstructParam>())).value as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectConstructParam),
            "::",
            stringify!(value)
        )
    );
}
extern "C" {
    pub fn g_object_class_install_property(
        oclass: *mut GObjectClass,
        property_id: guint,
        pspec: *mut GParamSpec,
    );
}
extern "C" {
    pub fn g_object_class_find_property(
        oclass: *mut GObjectClass,
        property_name: *const gchar,
    ) -> *mut GParamSpec;
}
extern "C" {
    pub fn g_object_class_list_properties(
        oclass: *mut GObjectClass,
        n_properties: *mut guint,
    ) -> *mut *mut GParamSpec;
}
extern "C" {
    pub fn g_object_class_override_property(
        oclass: *mut GObjectClass,
        property_id: guint,
        name: *const gchar,
    );
}
extern "C" {
    pub fn g_object_class_install_properties(
        oclass: *mut GObjectClass,
        n_pspecs: guint,
        pspecs: *mut *mut GParamSpec,
    );
}
extern "C" {
    pub fn g_object_interface_install_property(g_iface: gpointer, pspec: *mut GParamSpec);
}
extern "C" {
    pub fn g_object_interface_find_property(
        g_iface: gpointer,
        property_name: *const gchar,
    ) -> *mut GParamSpec;
}
extern "C" {
    pub fn g_object_interface_list_properties(
        g_iface: gpointer,
        n_properties_p: *mut guint,
    ) -> *mut *mut GParamSpec;
}
extern "C" {
    pub fn g_object_get_type() -> GType;
}
extern "C" {
    pub fn g_object_new(object_type: GType, first_property_name: *const gchar, ...) -> gpointer;
}
extern "C" {
    pub fn g_object_new_with_properties(
        object_type: GType,
        n_properties: guint,
        names: *mut *const ::std::os::raw::c_char,
        values: *const GValue,
    ) -> *mut GObject;
}
extern "C" {
    pub fn g_object_newv(
        object_type: GType,
        n_parameters: guint,
        parameters: *mut GParameter,
    ) -> gpointer;
}
extern "C" {
    pub fn g_object_new_valist(
        object_type: GType,
        first_property_name: *const gchar,
        var_args: *mut __va_list_tag,
    ) -> *mut GObject;
}
extern "C" {
    pub fn g_object_set(object: gpointer, first_property_name: *const gchar, ...);
}
extern "C" {
    pub fn g_object_get(object: gpointer, first_property_name: *const gchar, ...);
}
extern "C" {
    pub fn g_object_connect(object: gpointer, signal_spec: *const gchar, ...) -> gpointer;
}
extern "C" {
    pub fn g_object_disconnect(object: gpointer, signal_spec: *const gchar, ...);
}
extern "C" {
    pub fn g_object_setv(
        object: *mut GObject,
        n_properties: guint,
        names: *mut *const gchar,
        values: *const GValue,
    );
}
extern "C" {
    pub fn g_object_set_valist(
        object: *mut GObject,
        first_property_name: *const gchar,
        var_args: *mut __va_list_tag,
    );
}
extern "C" {
    pub fn g_object_getv(
        object: *mut GObject,
        n_properties: guint,
        names: *mut *const gchar,
        values: *mut GValue,
    );
}
extern "C" {
    pub fn g_object_get_valist(
        object: *mut GObject,
        first_property_name: *const gchar,
        var_args: *mut __va_list_tag,
    );
}
extern "C" {
    pub fn g_object_set_property(
        object: *mut GObject,
        property_name: *const gchar,
        value: *const GValue,
    );
}
extern "C" {
    pub fn g_object_get_property(
        object: *mut GObject,
        property_name: *const gchar,
        value: *mut GValue,
    );
}
extern "C" {
    pub fn g_object_freeze_notify(object: *mut GObject);
}
extern "C" {
    pub fn g_object_notify(object: *mut GObject, property_name: *const gchar);
}
extern "C" {
    pub fn g_object_notify_by_pspec(object: *mut GObject, pspec: *mut GParamSpec);
}
extern "C" {
    pub fn g_object_thaw_notify(object: *mut GObject);
}
extern "C" {
    pub fn g_object_is_floating(object: gpointer) -> gboolean;
}
extern "C" {
    pub fn g_object_ref_sink(object: gpointer) -> gpointer;
}
extern "C" {
    pub fn g_object_ref(object: gpointer) -> gpointer;
}
extern "C" {
    pub fn g_object_unref(object: gpointer);
}
extern "C" {
    pub fn g_object_weak_ref(object: *mut GObject, notify: GWeakNotify, data: gpointer);
}
extern "C" {
    pub fn g_object_weak_unref(object: *mut GObject, notify: GWeakNotify, data: gpointer);
}
extern "C" {
    pub fn g_object_add_weak_pointer(object: *mut GObject, weak_pointer_location: *mut gpointer);
}
extern "C" {
    pub fn g_object_remove_weak_pointer(object: *mut GObject, weak_pointer_location: *mut gpointer);
}
pub type GToggleNotify = ::std::option::Option<
    unsafe extern "C" fn(data: gpointer, object: *mut GObject, is_last_ref: gboolean),
>;
extern "C" {
    pub fn g_object_add_toggle_ref(object: *mut GObject, notify: GToggleNotify, data: gpointer);
}
extern "C" {
    pub fn g_object_remove_toggle_ref(object: *mut GObject, notify: GToggleNotify, data: gpointer);
}
extern "C" {
    pub fn g_object_get_qdata(object: *mut GObject, quark: GQuark) -> gpointer;
}
extern "C" {
    pub fn g_object_set_qdata(object: *mut GObject, quark: GQuark, data: gpointer);
}
extern "C" {
    pub fn g_object_set_qdata_full(
        object: *mut GObject,
        quark: GQuark,
        data: gpointer,
        destroy: GDestroyNotify,
    );
}
extern "C" {
    pub fn g_object_steal_qdata(object: *mut GObject, quark: GQuark) -> gpointer;
}
extern "C" {
    pub fn g_object_dup_qdata(
        object: *mut GObject,
        quark: GQuark,
        dup_func: GDuplicateFunc,
        user_data: gpointer,
    ) -> gpointer;
}
extern "C" {
    pub fn g_object_replace_qdata(
        object: *mut GObject,
        quark: GQuark,
        oldval: gpointer,
        newval: gpointer,
        destroy: GDestroyNotify,
        old_destroy: *mut GDestroyNotify,
    ) -> gboolean;
}
extern "C" {
    pub fn g_object_get_data(object: *mut GObject, key: *const gchar) -> gpointer;
}
extern "C" {
    pub fn g_object_set_data(object: *mut GObject, key: *const gchar, data: gpointer);
}
extern "C" {
    pub fn g_object_set_data_full(
        object: *mut GObject,
        key: *const gchar,
        data: gpointer,
        destroy: GDestroyNotify,
    );
}
extern "C" {
    pub fn g_object_steal_data(object: *mut GObject, key: *const gchar) -> gpointer;
}
extern "C" {
    pub fn g_object_dup_data(
        object: *mut GObject,
        key: *const gchar,
        dup_func: GDuplicateFunc,
        user_data: gpointer,
    ) -> gpointer;
}
extern "C" {
    pub fn g_object_replace_data(
        object: *mut GObject,
        key: *const gchar,
        oldval: gpointer,
        newval: gpointer,
        destroy: GDestroyNotify,
        old_destroy: *mut GDestroyNotify,
    ) -> gboolean;
}
extern "C" {
    pub fn g_object_watch_closure(object: *mut GObject, closure: *mut GClosure);
}
extern "C" {
    pub fn g_object_force_floating(object: *mut GObject);
}
extern "C" {
    pub fn g_object_run_dispose(object: *mut GObject);
}
extern "C" {
    pub fn g_object_compat_control(what: gsize, data: gpointer) -> gsize;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GBinding {
    _unused: [u8; 0],
}
pub type GBinding = _GBinding;
pub type GBindingTransformFunc = ::std::option::Option<
    unsafe extern "C" fn(
        binding: *mut GBinding,
        from_value: *const GValue,
        to_value: *mut GValue,
        user_data: gpointer,
    ) -> gboolean,
>;
pub const GBindingFlags_G_BINDING_DEFAULT: GBindingFlags = 0;
pub const GBindingFlags_G_BINDING_BIDIRECTIONAL: GBindingFlags = 1;
pub const GBindingFlags_G_BINDING_SYNC_CREATE: GBindingFlags = 2;
pub const GBindingFlags_G_BINDING_INVERT_BOOLEAN: GBindingFlags = 4;
pub type GBindingFlags = u32;
extern "C" {
    pub fn g_object_bind_property(
        source: gpointer,
        source_property: *const gchar,
        target: gpointer,
        target_property: *const gchar,
        flags: GBindingFlags,
    ) -> *mut GBinding;
}
extern "C" {
    pub fn g_object_bind_property_full(
        source: gpointer,
        source_property: *const gchar,
        target: gpointer,
        target_property: *const gchar,
        flags: GBindingFlags,
        transform_to: GBindingTransformFunc,
        transform_from: GBindingTransformFunc,
        user_data: gpointer,
        notify: GDestroyNotify,
    ) -> *mut GBinding;
}
extern "C" {
    pub fn g_object_bind_property_with_closures(
        source: gpointer,
        source_property: *const gchar,
        target: gpointer,
        target_property: *const gchar,
        flags: GBindingFlags,
        transform_to: *mut GClosure,
        transform_from: *mut GClosure,
    ) -> *mut GBinding;
}
pub type VipsPel = ::std::os::raw::c_uchar;
pub type VipsCallbackFn = ::std::option::Option<
    unsafe extern "C" fn(
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
>;
pub type VipsSListMap2Fn = ::std::option::Option<
    unsafe extern "C" fn(
        item: *mut ::std::os::raw::c_void,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void,
>;
pub type VipsSListMap4Fn = ::std::option::Option<
    unsafe extern "C" fn(
        item: *mut ::std::os::raw::c_void,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
        c: *mut ::std::os::raw::c_void,
        d: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void,
>;
pub type VipsSListFold2Fn = ::std::option::Option<
    unsafe extern "C" fn(
        item: *mut ::std::os::raw::c_void,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
        c: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void,
>;
pub const VipsPrecision_VIPS_PRECISION_INTEGER: VipsPrecision = 0;
pub const VipsPrecision_VIPS_PRECISION_FLOAT: VipsPrecision = 1;
pub const VipsPrecision_VIPS_PRECISION_APPROXIMATE: VipsPrecision = 2;
pub const VipsPrecision_VIPS_PRECISION_LAST: VipsPrecision = 3;
pub type VipsPrecision = u32;
extern "C" {
    pub fn vips_path_filename7(path: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_path_mode7(path: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsBuf {
    pub base: *mut ::std::os::raw::c_char,
    pub mx: ::std::os::raw::c_int,
    pub i: ::std::os::raw::c_int,
    pub full: gboolean,
    pub lasti: ::std::os::raw::c_int,
    pub dynamic: gboolean,
}
#[test]
fn bindgen_test_layout__VipsBuf() {
    assert_eq!(
        ::std::mem::size_of::<_VipsBuf>(),
        32usize,
        concat!("Size of: ", stringify!(_VipsBuf))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsBuf>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsBuf))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsBuf>())).base as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsBuf),
            "::",
            stringify!(base)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsBuf>())).mx as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsBuf),
            "::",
            stringify!(mx)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsBuf>())).i as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsBuf),
            "::",
            stringify!(i)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsBuf>())).full as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsBuf),
            "::",
            stringify!(full)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsBuf>())).lasti as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsBuf),
            "::",
            stringify!(lasti)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsBuf>())).dynamic as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsBuf),
            "::",
            stringify!(dynamic)
        )
    );
}
pub type VipsBuf = _VipsBuf;
extern "C" {
    pub fn vips_buf_rewind(buf: *mut VipsBuf);
}
extern "C" {
    pub fn vips_buf_destroy(buf: *mut VipsBuf);
}
extern "C" {
    pub fn vips_buf_init(buf: *mut VipsBuf);
}
extern "C" {
    pub fn vips_buf_set_static(
        buf: *mut VipsBuf,
        base: *mut ::std::os::raw::c_char,
        mx: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn vips_buf_set_dynamic(buf: *mut VipsBuf, mx: ::std::os::raw::c_int);
}
extern "C" {
    pub fn vips_buf_init_static(
        buf: *mut VipsBuf,
        base: *mut ::std::os::raw::c_char,
        mx: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn vips_buf_init_dynamic(buf: *mut VipsBuf, mx: ::std::os::raw::c_int);
}
extern "C" {
    pub fn vips_buf_appendns(
        buf: *mut VipsBuf,
        str: *const ::std::os::raw::c_char,
        sz: ::std::os::raw::c_int,
    ) -> gboolean;
}
extern "C" {
    pub fn vips_buf_appends(buf: *mut VipsBuf, str: *const ::std::os::raw::c_char) -> gboolean;
}
extern "C" {
    pub fn vips_buf_appendf(buf: *mut VipsBuf, fmt: *const ::std::os::raw::c_char, ...)
        -> gboolean;
}
extern "C" {
    pub fn vips_buf_vappendf(
        buf: *mut VipsBuf,
        fmt: *const ::std::os::raw::c_char,
        ap: *mut __va_list_tag,
    ) -> gboolean;
}
extern "C" {
    pub fn vips_buf_appendc(buf: *mut VipsBuf, ch: ::std::os::raw::c_char) -> gboolean;
}
extern "C" {
    pub fn vips_buf_appendsc(
        buf: *mut VipsBuf,
        quote: gboolean,
        str: *const ::std::os::raw::c_char,
    ) -> gboolean;
}
extern "C" {
    pub fn vips_buf_appendgv(buf: *mut VipsBuf, value: *mut GValue) -> gboolean;
}
extern "C" {
    pub fn vips_buf_append_size(buf: *mut VipsBuf, n: usize) -> gboolean;
}
extern "C" {
    pub fn vips_buf_removec(buf: *mut VipsBuf, ch: ::std::os::raw::c_char) -> gboolean;
}
extern "C" {
    pub fn vips_buf_change(
        buf: *mut VipsBuf,
        o: *const ::std::os::raw::c_char,
        n: *const ::std::os::raw::c_char,
    ) -> gboolean;
}
extern "C" {
    pub fn vips_buf_is_empty(buf: *mut VipsBuf) -> gboolean;
}
extern "C" {
    pub fn vips_buf_is_full(buf: *mut VipsBuf) -> gboolean;
}
extern "C" {
    pub fn vips_buf_all(buf: *mut VipsBuf) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_buf_firstline(buf: *mut VipsBuf) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_buf_appendg(buf: *mut VipsBuf, g: f64) -> gboolean;
}
extern "C" {
    pub fn vips_buf_appendd(buf: *mut VipsBuf, d: ::std::os::raw::c_int) -> gboolean;
}
extern "C" {
    pub fn vips_buf_len(buf: *mut VipsBuf) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsDbuf {
    pub data: *mut ::std::os::raw::c_uchar,
    pub allocated_size: usize,
    pub data_size: usize,
    pub write_point: usize,
}
#[test]
fn bindgen_test_layout__VipsDbuf() {
    assert_eq!(
        ::std::mem::size_of::<_VipsDbuf>(),
        32usize,
        concat!("Size of: ", stringify!(_VipsDbuf))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsDbuf>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsDbuf))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsDbuf>())).data as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsDbuf),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsDbuf>())).allocated_size as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsDbuf),
            "::",
            stringify!(allocated_size)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsDbuf>())).data_size as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsDbuf),
            "::",
            stringify!(data_size)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsDbuf>())).write_point as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsDbuf),
            "::",
            stringify!(write_point)
        )
    );
}
pub type VipsDbuf = _VipsDbuf;
extern "C" {
    pub fn vips_dbuf_destroy(dbuf: *mut VipsDbuf);
}
extern "C" {
    pub fn vips_dbuf_init(dbuf: *mut VipsDbuf);
}
extern "C" {
    pub fn vips_dbuf_allocate(dbuf: *mut VipsDbuf, size: usize) -> gboolean;
}
extern "C" {
    pub fn vips_dbuf_read(
        dbuf: *mut VipsDbuf,
        data: *mut ::std::os::raw::c_uchar,
        size: usize,
    ) -> usize;
}
extern "C" {
    pub fn vips_dbuf_get_write(
        dbuf: *mut VipsDbuf,
        size: *mut usize,
    ) -> *mut ::std::os::raw::c_uchar;
}
extern "C" {
    pub fn vips_dbuf_write(
        dbuf: *mut VipsDbuf,
        data: *const ::std::os::raw::c_uchar,
        size: usize,
    ) -> gboolean;
}
extern "C" {
    pub fn vips_dbuf_writef(
        dbuf: *mut VipsDbuf,
        fmt: *const ::std::os::raw::c_char,
        ...
    ) -> gboolean;
}
extern "C" {
    pub fn vips_dbuf_write_amp(dbuf: *mut VipsDbuf, str: *const ::std::os::raw::c_char)
        -> gboolean;
}
extern "C" {
    pub fn vips_dbuf_reset(dbuf: *mut VipsDbuf);
}
extern "C" {
    pub fn vips_dbuf_seek(
        dbuf: *mut VipsDbuf,
        offset: off_t,
        whence: ::std::os::raw::c_int,
    ) -> gboolean;
}
extern "C" {
    pub fn vips_dbuf_truncate(dbuf: *mut VipsDbuf);
}
extern "C" {
    pub fn vips_dbuf_tell(dbuf: *mut VipsDbuf) -> off_t;
}
extern "C" {
    pub fn vips_dbuf_string(dbuf: *mut VipsDbuf, size: *mut usize) -> *mut ::std::os::raw::c_uchar;
}
extern "C" {
    pub fn vips_dbuf_steal(dbuf: *mut VipsDbuf, size: *mut usize) -> *mut ::std::os::raw::c_uchar;
}
extern "C" {
    pub fn vips_enum_string(
        enm: GType,
        value: ::std::os::raw::c_int,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_enum_nick(
        enm: GType,
        value: ::std::os::raw::c_int,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_enum_from_nick(
        domain: *const ::std::os::raw::c_char,
        type_: GType,
        str: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_flags_from_nick(
        domain: *const ::std::os::raw::c_char,
        type_: GType,
        nick: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_slist_equal(l1: *mut GSList, l2: *mut GSList) -> gboolean;
}
extern "C" {
    pub fn vips_slist_map2(
        list: *mut GSList,
        fn_: VipsSListMap2Fn,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_slist_map2_rev(
        list: *mut GSList,
        fn_: VipsSListMap2Fn,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_slist_map4(
        list: *mut GSList,
        fn_: VipsSListMap4Fn,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
        c: *mut ::std::os::raw::c_void,
        d: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_slist_fold2(
        list: *mut GSList,
        start: *mut ::std::os::raw::c_void,
        fn_: VipsSListFold2Fn,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_slist_filter(
        list: *mut GSList,
        fn_: VipsSListMap2Fn,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut GSList;
}
extern "C" {
    pub fn vips_slist_free_all(list: *mut GSList);
}
extern "C" {
    pub fn vips_map_equal(
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_hash_table_map(
        hash: *mut GHashTable,
        fn_: VipsSListMap2Fn,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_strncpy(
        dest: *mut ::std::os::raw::c_char,
        src: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_strrstr(
        haystack: *const ::std::os::raw::c_char,
        needle: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_ispostfix(
        a: *const ::std::os::raw::c_char,
        b: *const ::std::os::raw::c_char,
    ) -> gboolean;
}
extern "C" {
    pub fn vips_iscasepostfix(
        a: *const ::std::os::raw::c_char,
        b: *const ::std::os::raw::c_char,
    ) -> gboolean;
}
extern "C" {
    pub fn vips_isprefix(
        a: *const ::std::os::raw::c_char,
        b: *const ::std::os::raw::c_char,
    ) -> gboolean;
}
extern "C" {
    pub fn vips_break_token(
        str: *mut ::std::os::raw::c_char,
        brk: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips__chomp(str: *mut ::std::os::raw::c_char);
}
extern "C" {
    pub fn vips_vsnprintf(
        str: *mut ::std::os::raw::c_char,
        size: usize,
        format: *const ::std::os::raw::c_char,
        ap: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_snprintf(
        str: *mut ::std::os::raw::c_char,
        size: usize,
        format: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_filename_suffix_match(
        path: *const ::std::os::raw::c_char,
        suffixes: *mut *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_file_length(fd: ::std::os::raw::c_int) -> gint64;
}
extern "C" {
    pub fn vips__write(
        fd: ::std::os::raw::c_int,
        buf: *const ::std::os::raw::c_void,
        count: usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips__open(
        filename: *const ::std::os::raw::c_char,
        flags: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips__open_read(filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips__fopen(
        filename: *const ::std::os::raw::c_char,
        mode: *const ::std::os::raw::c_char,
    ) -> *mut FILE;
}
extern "C" {
    pub fn vips__file_open_read(
        filename: *const ::std::os::raw::c_char,
        fallback_dir: *const ::std::os::raw::c_char,
        text_mode: gboolean,
    ) -> *mut FILE;
}
extern "C" {
    pub fn vips__file_open_write(
        filename: *const ::std::os::raw::c_char,
        text_mode: gboolean,
    ) -> *mut FILE;
}
extern "C" {
    pub fn vips__file_read(
        fp: *mut FILE,
        name: *const ::std::os::raw::c_char,
        length_out: *mut usize,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips__file_read_name(
        name: *const ::std::os::raw::c_char,
        fallback_dir: *const ::std::os::raw::c_char,
        length_out: *mut usize,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips__file_write(
        data: *mut ::std::os::raw::c_void,
        size: usize,
        nmemb: usize,
        stream: *mut FILE,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips__get_bytes(
        filename: *const ::std::os::raw::c_char,
        buf: *mut ::std::os::raw::c_uchar,
        len: guint64,
    ) -> guint64;
}
extern "C" {
    pub fn vips__fgetc(fp: *mut FILE) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips__gvalue_ref_string_new(text: *const ::std::os::raw::c_char) -> *mut GValue;
}
extern "C" {
    pub fn vips__gslist_gvalue_free(list: *mut GSList);
}
extern "C" {
    pub fn vips__gslist_gvalue_copy(list: *const GSList) -> *mut GSList;
}
extern "C" {
    pub fn vips__gslist_gvalue_merge(a: *mut GSList, b: *const GSList) -> *mut GSList;
}
extern "C" {
    pub fn vips__gslist_gvalue_get(list: *const GSList) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips__seek(fd: ::std::os::raw::c_int, pos: gint64) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips__ftruncate(fd: ::std::os::raw::c_int, pos: gint64) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_existsf(name: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_mkdirf(name: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_rmdirf(name: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_rename(
        old_name: *const ::std::os::raw::c_char,
        new_name: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_popenf(
        fmt: *const ::std::os::raw::c_char,
        mode: *const ::std::os::raw::c_char,
        ...
    ) -> *mut FILE;
}
pub const VipsToken_VIPS_TOKEN_LEFT: VipsToken = 1;
pub const VipsToken_VIPS_TOKEN_RIGHT: VipsToken = 2;
pub const VipsToken_VIPS_TOKEN_STRING: VipsToken = 3;
pub const VipsToken_VIPS_TOKEN_EQUALS: VipsToken = 4;
pub const VipsToken_VIPS_TOKEN_COMMA: VipsToken = 5;
pub type VipsToken = u32;
extern "C" {
    pub fn vips__token_get(
        buffer: *const ::std::os::raw::c_char,
        token: *mut VipsToken,
        string: *mut ::std::os::raw::c_char,
        size: ::std::os::raw::c_int,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips__token_must(
        buffer: *const ::std::os::raw::c_char,
        token: *mut VipsToken,
        string: *mut ::std::os::raw::c_char,
        size: ::std::os::raw::c_int,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips__token_need(
        buffer: *const ::std::os::raw::c_char,
        need_token: VipsToken,
        string: *mut ::std::os::raw::c_char,
        size: ::std::os::raw::c_int,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips__token_segment(
        p: *const ::std::os::raw::c_char,
        token: *mut VipsToken,
        string: *mut ::std::os::raw::c_char,
        size: ::std::os::raw::c_int,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips__token_segment_need(
        p: *const ::std::os::raw::c_char,
        need_token: VipsToken,
        string: *mut ::std::os::raw::c_char,
        size: ::std::os::raw::c_int,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips__find_rightmost_brackets(
        p: *const ::std::os::raw::c_char,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips__filename_split8(
        name: *const ::std::os::raw::c_char,
        filename: *mut ::std::os::raw::c_char,
        option_string: *mut ::std::os::raw::c_char,
    );
}
extern "C" {
    pub fn vips_ispoweroftwo(p: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_amiMSBfirst() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips__temp_name(format: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips__change_suffix(
        name: *const ::std::os::raw::c_char,
        out: *mut ::std::os::raw::c_char,
        mx: ::std::os::raw::c_int,
        new_suff: *const ::std::os::raw::c_char,
        olds: *mut *const ::std::os::raw::c_char,
        nolds: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn vips_realpath(path: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips__random(seed: guint32) -> guint32;
}
extern "C" {
    pub fn vips__random_add(seed: guint32, value: ::std::os::raw::c_int) -> guint32;
}
extern "C" {
    pub fn vips__icc_dir() -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips__windows_prefix() -> *const ::std::os::raw::c_char;
}
pub type VipsObject = _VipsObject;
pub type VipsObjectClass = _VipsObjectClass;
pub const VipsArgumentFlags_VIPS_ARGUMENT_NONE: VipsArgumentFlags = 0;
pub const VipsArgumentFlags_VIPS_ARGUMENT_REQUIRED: VipsArgumentFlags = 1;
pub const VipsArgumentFlags_VIPS_ARGUMENT_CONSTRUCT: VipsArgumentFlags = 2;
pub const VipsArgumentFlags_VIPS_ARGUMENT_SET_ONCE: VipsArgumentFlags = 4;
pub const VipsArgumentFlags_VIPS_ARGUMENT_SET_ALWAYS: VipsArgumentFlags = 8;
pub const VipsArgumentFlags_VIPS_ARGUMENT_INPUT: VipsArgumentFlags = 16;
pub const VipsArgumentFlags_VIPS_ARGUMENT_OUTPUT: VipsArgumentFlags = 32;
pub const VipsArgumentFlags_VIPS_ARGUMENT_DEPRECATED: VipsArgumentFlags = 64;
pub const VipsArgumentFlags_VIPS_ARGUMENT_MODIFY: VipsArgumentFlags = 128;
pub type VipsArgumentFlags = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsArgument {
    pub pspec: *mut GParamSpec,
}
#[test]
fn bindgen_test_layout__VipsArgument() {
    assert_eq!(
        ::std::mem::size_of::<_VipsArgument>(),
        8usize,
        concat!("Size of: ", stringify!(_VipsArgument))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsArgument>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsArgument))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArgument>())).pspec as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArgument),
            "::",
            stringify!(pspec)
        )
    );
}
pub type VipsArgument = _VipsArgument;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsArgumentClass {
    pub parent: VipsArgument,
    pub object_class: *mut VipsObjectClass,
    pub flags: VipsArgumentFlags,
    pub priority: ::std::os::raw::c_int,
    pub offset: guint,
}
#[test]
fn bindgen_test_layout__VipsArgumentClass() {
    assert_eq!(
        ::std::mem::size_of::<_VipsArgumentClass>(),
        32usize,
        concat!("Size of: ", stringify!(_VipsArgumentClass))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsArgumentClass>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsArgumentClass))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArgumentClass>())).parent as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArgumentClass),
            "::",
            stringify!(parent)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArgumentClass>())).object_class as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArgumentClass),
            "::",
            stringify!(object_class)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArgumentClass>())).flags as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArgumentClass),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArgumentClass>())).priority as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArgumentClass),
            "::",
            stringify!(priority)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArgumentClass>())).offset as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArgumentClass),
            "::",
            stringify!(offset)
        )
    );
}
pub type VipsArgumentClass = _VipsArgumentClass;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsArgumentInstance {
    pub parent: VipsArgument,
    pub argument_class: *mut VipsArgumentClass,
    pub object: *mut VipsObject,
    pub assigned: gboolean,
    pub close_id: gulong,
    pub invalidate_id: gulong,
}
#[test]
fn bindgen_test_layout__VipsArgumentInstance() {
    assert_eq!(
        ::std::mem::size_of::<_VipsArgumentInstance>(),
        48usize,
        concat!("Size of: ", stringify!(_VipsArgumentInstance))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsArgumentInstance>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsArgumentInstance))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArgumentInstance>())).parent as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArgumentInstance),
            "::",
            stringify!(parent)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsArgumentInstance>())).argument_class as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArgumentInstance),
            "::",
            stringify!(argument_class)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArgumentInstance>())).object as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArgumentInstance),
            "::",
            stringify!(object)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArgumentInstance>())).assigned as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArgumentInstance),
            "::",
            stringify!(assigned)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArgumentInstance>())).close_id as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArgumentInstance),
            "::",
            stringify!(close_id)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsArgumentInstance>())).invalidate_id as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArgumentInstance),
            "::",
            stringify!(invalidate_id)
        )
    );
}
pub type VipsArgumentInstance = _VipsArgumentInstance;
pub type VipsArgumentTable = GHashTable;
extern "C" {
    pub fn vips_argument_get_id() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips__object_set_member(
        object: *mut VipsObject,
        pspec: *mut GParamSpec,
        member: *mut *mut GObject,
        argument: *mut GObject,
    );
}
pub type VipsArgumentMapFn = ::std::option::Option<
    unsafe extern "C" fn(
        object: *mut VipsObject,
        pspec: *mut GParamSpec,
        argument_class: *mut VipsArgumentClass,
        argument_instance: *mut VipsArgumentInstance,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void,
>;
extern "C" {
    pub fn vips_argument_map(
        object: *mut VipsObject,
        fn_: VipsArgumentMapFn,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_object_get_args(
        object: *mut VipsObject,
        names: *mut *mut *const ::std::os::raw::c_char,
        flags: *mut *mut ::std::os::raw::c_int,
        n_args: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
pub type VipsArgumentClassMapFn = ::std::option::Option<
    unsafe extern "C" fn(
        object_class: *mut VipsObjectClass,
        pspec: *mut GParamSpec,
        argument_class: *mut VipsArgumentClass,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void,
>;
extern "C" {
    pub fn vips_argument_class_map(
        object_class: *mut VipsObjectClass,
        fn_: VipsArgumentClassMapFn,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_argument_class_needsstring(argument_class: *mut VipsArgumentClass) -> gboolean;
}
extern "C" {
    pub fn vips_object_get_argument(
        object: *mut VipsObject,
        name: *const ::std::os::raw::c_char,
        pspec: *mut *mut GParamSpec,
        argument_class: *mut *mut VipsArgumentClass,
        argument_instance: *mut *mut VipsArgumentInstance,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_object_argument_isset(
        object: *mut VipsObject,
        name: *const ::std::os::raw::c_char,
    ) -> gboolean;
}
extern "C" {
    pub fn vips_object_get_argument_flags(
        object: *mut VipsObject,
        name: *const ::std::os::raw::c_char,
    ) -> VipsArgumentFlags;
}
extern "C" {
    pub fn vips_object_get_argument_priority(
        object: *mut VipsObject,
        name: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsObject {
    pub parent_instance: GObject,
    pub constructed: gboolean,
    pub static_object: gboolean,
    pub argument_table: *mut VipsArgumentTable,
    pub nickname: *mut ::std::os::raw::c_char,
    pub description: *mut ::std::os::raw::c_char,
    pub preclose: gboolean,
    pub close: gboolean,
    pub postclose: gboolean,
    pub local_memory: usize,
}
#[test]
fn bindgen_test_layout__VipsObject() {
    assert_eq!(
        ::std::mem::size_of::<_VipsObject>(),
        80usize,
        concat!("Size of: ", stringify!(_VipsObject))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsObject>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsObject))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObject>())).parent_instance as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObject),
            "::",
            stringify!(parent_instance)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObject>())).constructed as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObject),
            "::",
            stringify!(constructed)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObject>())).static_object as *const _ as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObject),
            "::",
            stringify!(static_object)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObject>())).argument_table as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObject),
            "::",
            stringify!(argument_table)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObject>())).nickname as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObject),
            "::",
            stringify!(nickname)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObject>())).description as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObject),
            "::",
            stringify!(description)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObject>())).preclose as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObject),
            "::",
            stringify!(preclose)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObject>())).close as *const _ as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObject),
            "::",
            stringify!(close)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObject>())).postclose as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObject),
            "::",
            stringify!(postclose)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObject>())).local_memory as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObject),
            "::",
            stringify!(local_memory)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsObjectClass {
    pub parent_class: GObjectClass,
    pub build: ::std::option::Option<
        unsafe extern "C" fn(object: *mut VipsObject) -> ::std::os::raw::c_int,
    >,
    pub postbuild: ::std::option::Option<
        unsafe extern "C" fn(object: *mut VipsObject) -> ::std::os::raw::c_int,
    >,
    pub summary_class:
        ::std::option::Option<unsafe extern "C" fn(cls: *mut _VipsObjectClass, buf: *mut VipsBuf)>,
    pub summary:
        ::std::option::Option<unsafe extern "C" fn(object: *mut VipsObject, buf: *mut VipsBuf)>,
    pub dump:
        ::std::option::Option<unsafe extern "C" fn(object: *mut VipsObject, buf: *mut VipsBuf)>,
    pub sanity:
        ::std::option::Option<unsafe extern "C" fn(object: *mut VipsObject, buf: *mut VipsBuf)>,
    pub rewind: ::std::option::Option<unsafe extern "C" fn(object: *mut VipsObject)>,
    pub preclose: ::std::option::Option<unsafe extern "C" fn(object: *mut VipsObject)>,
    pub close: ::std::option::Option<unsafe extern "C" fn(object: *mut VipsObject)>,
    pub postclose: ::std::option::Option<unsafe extern "C" fn(object: *mut VipsObject)>,
    pub new_from_string: ::std::option::Option<
        unsafe extern "C" fn(string: *const ::std::os::raw::c_char) -> *mut VipsObject,
    >,
    pub to_string:
        ::std::option::Option<unsafe extern "C" fn(object: *mut VipsObject, buf: *mut VipsBuf)>,
    pub output_needs_arg: gboolean,
    pub output_to_arg: ::std::option::Option<
        unsafe extern "C" fn(
            object: *mut VipsObject,
            string: *const ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
    pub nickname: *const ::std::os::raw::c_char,
    pub description: *const ::std::os::raw::c_char,
    pub argument_table: *mut VipsArgumentTable,
    pub argument_table_traverse: *mut GSList,
    pub argument_table_traverse_gtype: GType,
    pub deprecated: gboolean,
    pub _vips_reserved1: ::std::option::Option<unsafe extern "C" fn()>,
    pub _vips_reserved2: ::std::option::Option<unsafe extern "C" fn()>,
    pub _vips_reserved3: ::std::option::Option<unsafe extern "C" fn()>,
    pub _vips_reserved4: ::std::option::Option<unsafe extern "C" fn()>,
}
#[test]
fn bindgen_test_layout__VipsObjectClass() {
    assert_eq!(
        ::std::mem::size_of::<_VipsObjectClass>(),
        328usize,
        concat!("Size of: ", stringify!(_VipsObjectClass))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsObjectClass>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsObjectClass))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObjectClass>())).parent_class as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(parent_class)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObjectClass>())).build as *const _ as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(build)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObjectClass>())).postbuild as *const _ as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(postbuild)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObjectClass>())).summary_class as *const _ as usize },
        152usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(summary_class)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObjectClass>())).summary as *const _ as usize },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(summary)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObjectClass>())).dump as *const _ as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(dump)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObjectClass>())).sanity as *const _ as usize },
        176usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(sanity)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObjectClass>())).rewind as *const _ as usize },
        184usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(rewind)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObjectClass>())).preclose as *const _ as usize },
        192usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(preclose)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObjectClass>())).close as *const _ as usize },
        200usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(close)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObjectClass>())).postclose as *const _ as usize },
        208usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(postclose)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsObjectClass>())).new_from_string as *const _ as usize
        },
        216usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(new_from_string)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObjectClass>())).to_string as *const _ as usize },
        224usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(to_string)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsObjectClass>())).output_needs_arg as *const _ as usize
        },
        232usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(output_needs_arg)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObjectClass>())).output_to_arg as *const _ as usize },
        240usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(output_to_arg)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObjectClass>())).nickname as *const _ as usize },
        248usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(nickname)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObjectClass>())).description as *const _ as usize },
        256usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(description)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObjectClass>())).argument_table as *const _ as usize },
        264usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(argument_table)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsObjectClass>())).argument_table_traverse as *const _
                as usize
        },
        272usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(argument_table_traverse)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsObjectClass>())).argument_table_traverse_gtype as *const _
                as usize
        },
        280usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(argument_table_traverse_gtype)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsObjectClass>())).deprecated as *const _ as usize },
        288usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(deprecated)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsObjectClass>()))._vips_reserved1 as *const _ as usize
        },
        296usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(_vips_reserved1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsObjectClass>()))._vips_reserved2 as *const _ as usize
        },
        304usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(_vips_reserved2)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsObjectClass>()))._vips_reserved3 as *const _ as usize
        },
        312usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(_vips_reserved3)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsObjectClass>()))._vips_reserved4 as *const _ as usize
        },
        320usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsObjectClass),
            "::",
            stringify!(_vips_reserved4)
        )
    );
}
extern "C" {
    pub fn vips_value_is_null(psoec: *mut GParamSpec, value: *const GValue) -> gboolean;
}
extern "C" {
    pub fn vips_object_set_property(
        gobject: *mut GObject,
        property_id: guint,
        value: *const GValue,
        pspec: *mut GParamSpec,
    );
}
extern "C" {
    pub fn vips_object_get_property(
        gobject: *mut GObject,
        property_id: guint,
        value: *mut GValue,
        pspec: *mut GParamSpec,
    );
}
extern "C" {
    pub fn vips_object_preclose(object: *mut VipsObject);
}
extern "C" {
    pub fn vips_object_build(object: *mut VipsObject) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_object_summary_class(klass: *mut VipsObjectClass, buf: *mut VipsBuf);
}
extern "C" {
    pub fn vips_object_summary(object: *mut VipsObject, buf: *mut VipsBuf);
}
extern "C" {
    pub fn vips_object_dump(object: *mut VipsObject, buf: *mut VipsBuf);
}
extern "C" {
    pub fn vips_object_print_summary_class(klass: *mut VipsObjectClass);
}
extern "C" {
    pub fn vips_object_print_summary(object: *mut VipsObject);
}
extern "C" {
    pub fn vips_object_print_dump(object: *mut VipsObject);
}
extern "C" {
    pub fn vips_object_print_name(object: *mut VipsObject);
}
extern "C" {
    pub fn vips_object_sanity(object: *mut VipsObject) -> gboolean;
}
extern "C" {
    pub fn vips_object_get_type() -> GType;
}
extern "C" {
    pub fn vips_object_class_install_argument(
        cls: *mut VipsObjectClass,
        pspec: *mut GParamSpec,
        flags: VipsArgumentFlags,
        priority: ::std::os::raw::c_int,
        offset: guint,
    );
}
extern "C" {
    pub fn vips_object_set_argument_from_string(
        object: *mut VipsObject,
        name: *const ::std::os::raw::c_char,
        value: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_object_argument_needsstring(
        object: *mut VipsObject,
        name: *const ::std::os::raw::c_char,
    ) -> gboolean;
}
extern "C" {
    pub fn vips_object_get_argument_to_string(
        object: *mut VipsObject,
        name: *const ::std::os::raw::c_char,
        arg: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_object_set_required(
        object: *mut VipsObject,
        value: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
pub type VipsObjectSetArguments = ::std::option::Option<
    unsafe extern "C" fn(
        object: *mut VipsObject,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void,
>;
extern "C" {
    pub fn vips_object_new(
        type_: GType,
        set: VipsObjectSetArguments,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut VipsObject;
}
extern "C" {
    pub fn vips_object_set_valist(
        object: *mut VipsObject,
        ap: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_object_set(object: *mut VipsObject, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_object_set_from_string(
        object: *mut VipsObject,
        string: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_object_new_from_string(
        object_class: *mut VipsObjectClass,
        p: *const ::std::os::raw::c_char,
    ) -> *mut VipsObject;
}
extern "C" {
    pub fn vips_object_to_string(object: *mut VipsObject, buf: *mut VipsBuf);
}
extern "C" {
    pub fn vips_object_map(
        fn_: VipsSListMap2Fn,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void;
}
pub type VipsTypeMapFn = ::std::option::Option<
    unsafe extern "C" fn(
        type_: GType,
        a: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void,
>;
pub type VipsTypeMap2Fn = ::std::option::Option<
    unsafe extern "C" fn(
        type_: GType,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void,
>;
pub type VipsClassMapFn = ::std::option::Option<
    unsafe extern "C" fn(
        cls: *mut VipsObjectClass,
        a: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void,
>;
extern "C" {
    pub fn vips_type_map(
        base: GType,
        fn_: VipsTypeMap2Fn,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_type_map_all(
        base: GType,
        fn_: VipsTypeMapFn,
        a: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_type_depth(type_: GType) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_type_find(
        basename: *const ::std::os::raw::c_char,
        nickname: *const ::std::os::raw::c_char,
    ) -> GType;
}
extern "C" {
    pub fn vips_nickname_find(type_: GType) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_class_map_all(
        type_: GType,
        fn_: VipsClassMapFn,
        a: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_class_find(
        basename: *const ::std::os::raw::c_char,
        nickname: *const ::std::os::raw::c_char,
    ) -> *const VipsObjectClass;
}
extern "C" {
    pub fn vips_object_local_array(
        parent: *mut VipsObject,
        n: ::std::os::raw::c_int,
    ) -> *mut *mut VipsObject;
}
extern "C" {
    pub fn vips_object_local_cb(vobject: *mut VipsObject, gobject: *mut GObject);
}
extern "C" {
    pub fn vips_object_set_static(object: *mut VipsObject, static_object: gboolean);
}
extern "C" {
    pub fn vips_object_print_all();
}
extern "C" {
    pub fn vips_object_sanity_all();
}
extern "C" {
    pub fn vips_object_rewind(object: *mut VipsObject);
}
extern "C" {
    pub fn vips_object_unref_outputs(object: *mut VipsObject);
}
extern "C" {
    pub fn vips_object_get_description(object: *mut VipsObject) -> *const ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsThing {
    pub i: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__VipsThing() {
    assert_eq!(
        ::std::mem::size_of::<_VipsThing>(),
        4usize,
        concat!("Size of: ", stringify!(_VipsThing))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsThing>(),
        4usize,
        concat!("Alignment of ", stringify!(_VipsThing))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsThing>())).i as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsThing),
            "::",
            stringify!(i)
        )
    );
}
pub type VipsThing = _VipsThing;
extern "C" {
    pub fn vips_thing_get_type() -> GType;
}
extern "C" {
    pub fn vips_thing_new(i: ::std::os::raw::c_int) -> *mut VipsThing;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsArea {
    pub data: *mut ::std::os::raw::c_void,
    pub length: usize,
    pub n: ::std::os::raw::c_int,
    pub count: ::std::os::raw::c_int,
    pub lock: *mut GMutex,
    pub free_fn: VipsCallbackFn,
    pub type_: GType,
    pub sizeof_type: usize,
}
#[test]
fn bindgen_test_layout__VipsArea() {
    assert_eq!(
        ::std::mem::size_of::<_VipsArea>(),
        56usize,
        concat!("Size of: ", stringify!(_VipsArea))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsArea>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsArea))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArea>())).data as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArea),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArea>())).length as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArea),
            "::",
            stringify!(length)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArea>())).n as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArea),
            "::",
            stringify!(n)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArea>())).count as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArea),
            "::",
            stringify!(count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArea>())).lock as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArea),
            "::",
            stringify!(lock)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArea>())).free_fn as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArea),
            "::",
            stringify!(free_fn)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArea>())).type_ as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArea),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArea>())).sizeof_type as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArea),
            "::",
            stringify!(sizeof_type)
        )
    );
}
pub type VipsArea = _VipsArea;
extern "C" {
    pub fn vips_area_copy(area: *mut VipsArea) -> *mut VipsArea;
}
extern "C" {
    pub fn vips_area_unref(area: *mut VipsArea);
}
extern "C" {
    pub fn vips_area_new(
        free_fn: VipsCallbackFn,
        data: *mut ::std::os::raw::c_void,
    ) -> *mut VipsArea;
}
extern "C" {
    pub fn vips_area_new_array(
        type_: GType,
        sizeof_type: usize,
        n: ::std::os::raw::c_int,
    ) -> *mut VipsArea;
}
extern "C" {
    pub fn vips_area_new_array_object(n: ::std::os::raw::c_int) -> *mut VipsArea;
}
extern "C" {
    pub fn vips_area_get_data(
        area: *mut VipsArea,
        length: *mut usize,
        n: *mut ::std::os::raw::c_int,
        type_: *mut GType,
        sizeof_type: *mut usize,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_area_get_type() -> GType;
}
extern "C" {
    pub fn vips_save_string_get_type() -> GType;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsRefString {
    pub area: VipsArea,
}
#[test]
fn bindgen_test_layout__VipsRefString() {
    assert_eq!(
        ::std::mem::size_of::<_VipsRefString>(),
        56usize,
        concat!("Size of: ", stringify!(_VipsRefString))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsRefString>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsRefString))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsRefString>())).area as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsRefString),
            "::",
            stringify!(area)
        )
    );
}
pub type VipsRefString = _VipsRefString;
extern "C" {
    pub fn vips_ref_string_new(str: *const ::std::os::raw::c_char) -> *mut VipsRefString;
}
extern "C" {
    pub fn vips_ref_string_get(
        refstr: *mut VipsRefString,
        length: *mut usize,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_ref_string_get_type() -> GType;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsBlob {
    pub area: VipsArea,
}
#[test]
fn bindgen_test_layout__VipsBlob() {
    assert_eq!(
        ::std::mem::size_of::<_VipsBlob>(),
        56usize,
        concat!("Size of: ", stringify!(_VipsBlob))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsBlob>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsBlob))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsBlob>())).area as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsBlob),
            "::",
            stringify!(area)
        )
    );
}
pub type VipsBlob = _VipsBlob;
extern "C" {
    pub fn vips_blob_new(
        free_fn: VipsCallbackFn,
        data: *const ::std::os::raw::c_void,
        length: usize,
    ) -> *mut VipsBlob;
}
extern "C" {
    pub fn vips_blob_copy(data: *const ::std::os::raw::c_void, length: usize) -> *mut VipsBlob;
}
extern "C" {
    pub fn vips_blob_get(blob: *mut VipsBlob, length: *mut usize) -> *const ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_blob_get_type() -> GType;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsArrayDouble {
    pub area: VipsArea,
}
#[test]
fn bindgen_test_layout__VipsArrayDouble() {
    assert_eq!(
        ::std::mem::size_of::<_VipsArrayDouble>(),
        56usize,
        concat!("Size of: ", stringify!(_VipsArrayDouble))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsArrayDouble>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsArrayDouble))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArrayDouble>())).area as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArrayDouble),
            "::",
            stringify!(area)
        )
    );
}
pub type VipsArrayDouble = _VipsArrayDouble;
extern "C" {
    pub fn vips_array_double_new(
        array: *const f64,
        n: ::std::os::raw::c_int,
    ) -> *mut VipsArrayDouble;
}
extern "C" {
    pub fn vips_array_double_newv(n: ::std::os::raw::c_int, ...) -> *mut VipsArrayDouble;
}
extern "C" {
    pub fn vips_array_double_get(
        array: *mut VipsArrayDouble,
        n: *mut ::std::os::raw::c_int,
    ) -> *mut f64;
}
extern "C" {
    pub fn vips_array_double_get_type() -> GType;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsArrayInt {
    pub area: VipsArea,
}
#[test]
fn bindgen_test_layout__VipsArrayInt() {
    assert_eq!(
        ::std::mem::size_of::<_VipsArrayInt>(),
        56usize,
        concat!("Size of: ", stringify!(_VipsArrayInt))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsArrayInt>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsArrayInt))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArrayInt>())).area as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArrayInt),
            "::",
            stringify!(area)
        )
    );
}
pub type VipsArrayInt = _VipsArrayInt;
extern "C" {
    pub fn vips_array_int_new(
        array: *const ::std::os::raw::c_int,
        n: ::std::os::raw::c_int,
    ) -> *mut VipsArrayInt;
}
extern "C" {
    pub fn vips_array_int_newv(n: ::std::os::raw::c_int, ...) -> *mut VipsArrayInt;
}
extern "C" {
    pub fn vips_array_int_get(
        array: *mut VipsArrayInt,
        n: *mut ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_array_int_get_type() -> GType;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsArrayImage {
    pub area: VipsArea,
}
#[test]
fn bindgen_test_layout__VipsArrayImage() {
    assert_eq!(
        ::std::mem::size_of::<_VipsArrayImage>(),
        56usize,
        concat!("Size of: ", stringify!(_VipsArrayImage))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsArrayImage>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsArrayImage))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsArrayImage>())).area as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsArrayImage),
            "::",
            stringify!(area)
        )
    );
}
pub type VipsArrayImage = _VipsArrayImage;
extern "C" {
    pub fn vips_array_image_get_type() -> GType;
}
extern "C" {
    pub fn vips_value_set_area(
        value: *mut GValue,
        free_fn: VipsCallbackFn,
        data: *mut ::std::os::raw::c_void,
    );
}
extern "C" {
    pub fn vips_value_get_area(
        value: *const GValue,
        length: *mut usize,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_value_get_save_string(value: *const GValue) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_value_set_save_string(value: *mut GValue, str: *const ::std::os::raw::c_char);
}
extern "C" {
    pub fn vips_value_set_save_stringf(value: *mut GValue, fmt: *const ::std::os::raw::c_char, ...);
}
extern "C" {
    pub fn vips_value_get_ref_string(
        value: *const GValue,
        length: *mut usize,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_value_set_ref_string(value: *mut GValue, str: *const ::std::os::raw::c_char);
}
extern "C" {
    pub fn vips_value_get_blob(
        value: *const GValue,
        length: *mut usize,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_value_set_blob(
        value: *mut GValue,
        free_fn: VipsCallbackFn,
        data: *const ::std::os::raw::c_void,
        length: usize,
    );
}
extern "C" {
    pub fn vips_value_set_blob_free(
        value: *mut GValue,
        data: *mut ::std::os::raw::c_void,
        length: usize,
    );
}
extern "C" {
    pub fn vips_value_set_array(
        value: *mut GValue,
        n: ::std::os::raw::c_int,
        type_: GType,
        sizeof_type: usize,
    );
}
extern "C" {
    pub fn vips_value_get_array(
        value: *const GValue,
        n: *mut ::std::os::raw::c_int,
        type_: *mut GType,
        sizeof_type: *mut usize,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_value_get_array_double(
        value: *const GValue,
        n: *mut ::std::os::raw::c_int,
    ) -> *mut f64;
}
extern "C" {
    pub fn vips_value_set_array_double(
        value: *mut GValue,
        array: *const f64,
        n: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn vips_value_get_array_int(
        value: *const GValue,
        n: *mut ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_value_set_array_int(
        value: *mut GValue,
        array: *const ::std::os::raw::c_int,
        n: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn vips_value_get_array_object(
        value: *const GValue,
        n: *mut ::std::os::raw::c_int,
    ) -> *mut *mut GObject;
}
extern "C" {
    pub fn vips_value_set_array_object(value: *mut GValue, n: ::std::os::raw::c_int);
}
extern "C" {
    pub fn vips_profile_set(profile: gboolean);
}
extern "C" {
    pub fn vips__thread_profile_attach(thread_name: *const ::std::os::raw::c_char);
}
extern "C" {
    pub fn vips__thread_profile_detach();
}
extern "C" {
    pub fn vips__thread_profile_stop();
}
extern "C" {
    pub fn vips__thread_gate_start(gate_name: *const ::std::os::raw::c_char);
}
extern "C" {
    pub fn vips__thread_gate_stop(gate_name: *const ::std::os::raw::c_char);
}
extern "C" {
    pub fn vips__thread_malloc_free(size: gint64);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsRect {
    pub left: ::std::os::raw::c_int,
    pub top: ::std::os::raw::c_int,
    pub width: ::std::os::raw::c_int,
    pub height: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__VipsRect() {
    assert_eq!(
        ::std::mem::size_of::<_VipsRect>(),
        16usize,
        concat!("Size of: ", stringify!(_VipsRect))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsRect>(),
        4usize,
        concat!("Alignment of ", stringify!(_VipsRect))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsRect>())).left as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsRect),
            "::",
            stringify!(left)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsRect>())).top as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsRect),
            "::",
            stringify!(top)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsRect>())).width as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsRect),
            "::",
            stringify!(width)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsRect>())).height as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsRect),
            "::",
            stringify!(height)
        )
    );
}
pub type VipsRect = _VipsRect;
extern "C" {
    pub fn vips_rect_isempty(r: *const VipsRect) -> gboolean;
}
extern "C" {
    pub fn vips_rect_includespoint(
        r: *const VipsRect,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
    ) -> gboolean;
}
extern "C" {
    pub fn vips_rect_includesrect(r1: *const VipsRect, r2: *const VipsRect) -> gboolean;
}
extern "C" {
    pub fn vips_rect_equalsrect(r1: *const VipsRect, r2: *const VipsRect) -> gboolean;
}
extern "C" {
    pub fn vips_rect_overlapsrect(r1: *const VipsRect, r2: *const VipsRect) -> gboolean;
}
extern "C" {
    pub fn vips_rect_marginadjust(r: *mut VipsRect, n: ::std::os::raw::c_int);
}
extern "C" {
    pub fn vips_rect_intersectrect(r1: *const VipsRect, r2: *const VipsRect, out: *mut VipsRect);
}
extern "C" {
    pub fn vips_rect_unionrect(r1: *const VipsRect, r2: *const VipsRect, out: *mut VipsRect);
}
extern "C" {
    pub fn vips_rect_dup(r: *const VipsRect) -> *mut VipsRect;
}
extern "C" {
    pub fn vips_rect_normalise(r: *mut VipsRect);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VipsWindow {
    pub ref_count: ::std::os::raw::c_int,
    pub im: *mut _VipsImage,
    pub top: ::std::os::raw::c_int,
    pub height: ::std::os::raw::c_int,
    pub data: *mut VipsPel,
    pub baseaddr: *mut ::std::os::raw::c_void,
    pub length: usize,
}
#[test]
fn bindgen_test_layout_VipsWindow() {
    assert_eq!(
        ::std::mem::size_of::<VipsWindow>(),
        48usize,
        concat!("Size of: ", stringify!(VipsWindow))
    );
    assert_eq!(
        ::std::mem::align_of::<VipsWindow>(),
        8usize,
        concat!("Alignment of ", stringify!(VipsWindow))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<VipsWindow>())).ref_count as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(VipsWindow),
            "::",
            stringify!(ref_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<VipsWindow>())).im as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(VipsWindow),
            "::",
            stringify!(im)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<VipsWindow>())).top as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(VipsWindow),
            "::",
            stringify!(top)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<VipsWindow>())).height as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(VipsWindow),
            "::",
            stringify!(height)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<VipsWindow>())).data as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(VipsWindow),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<VipsWindow>())).baseaddr as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(VipsWindow),
            "::",
            stringify!(baseaddr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<VipsWindow>())).length as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(VipsWindow),
            "::",
            stringify!(length)
        )
    );
}
extern "C" {
    pub fn vips_window_unref(window: *mut VipsWindow) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_window_print(window: *mut VipsWindow);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VipsBufferThread {
    pub hash: *mut GHashTable,
    pub thread: *mut GThread,
}
#[test]
fn bindgen_test_layout_VipsBufferThread() {
    assert_eq!(
        ::std::mem::size_of::<VipsBufferThread>(),
        16usize,
        concat!("Size of: ", stringify!(VipsBufferThread))
    );
    assert_eq!(
        ::std::mem::align_of::<VipsBufferThread>(),
        8usize,
        concat!("Alignment of ", stringify!(VipsBufferThread))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<VipsBufferThread>())).hash as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(VipsBufferThread),
            "::",
            stringify!(hash)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<VipsBufferThread>())).thread as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(VipsBufferThread),
            "::",
            stringify!(thread)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsBufferCache {
    pub buffers: *mut GSList,
    pub thread: *mut GThread,
    pub im: *mut _VipsImage,
    pub buffer_thread: *mut VipsBufferThread,
    pub reserve: *mut GSList,
    pub n_reserve: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__VipsBufferCache() {
    assert_eq!(
        ::std::mem::size_of::<_VipsBufferCache>(),
        48usize,
        concat!("Size of: ", stringify!(_VipsBufferCache))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsBufferCache>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsBufferCache))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsBufferCache>())).buffers as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsBufferCache),
            "::",
            stringify!(buffers)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsBufferCache>())).thread as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsBufferCache),
            "::",
            stringify!(thread)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsBufferCache>())).im as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsBufferCache),
            "::",
            stringify!(im)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsBufferCache>())).buffer_thread as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsBufferCache),
            "::",
            stringify!(buffer_thread)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsBufferCache>())).reserve as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsBufferCache),
            "::",
            stringify!(reserve)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsBufferCache>())).n_reserve as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsBufferCache),
            "::",
            stringify!(n_reserve)
        )
    );
}
pub type VipsBufferCache = _VipsBufferCache;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsBuffer {
    pub ref_count: ::std::os::raw::c_int,
    pub im: *mut _VipsImage,
    pub area: VipsRect,
    pub done: gboolean,
    pub cache: *mut VipsBufferCache,
    pub buf: *mut VipsPel,
    pub bsize: usize,
}
#[test]
fn bindgen_test_layout__VipsBuffer() {
    assert_eq!(
        ::std::mem::size_of::<_VipsBuffer>(),
        64usize,
        concat!("Size of: ", stringify!(_VipsBuffer))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsBuffer>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsBuffer))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsBuffer>())).ref_count as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsBuffer),
            "::",
            stringify!(ref_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsBuffer>())).im as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsBuffer),
            "::",
            stringify!(im)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsBuffer>())).area as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsBuffer),
            "::",
            stringify!(area)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsBuffer>())).done as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsBuffer),
            "::",
            stringify!(done)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsBuffer>())).cache as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsBuffer),
            "::",
            stringify!(cache)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsBuffer>())).buf as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsBuffer),
            "::",
            stringify!(buf)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsBuffer>())).bsize as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsBuffer),
            "::",
            stringify!(bsize)
        )
    );
}
pub type VipsBuffer = _VipsBuffer;
extern "C" {
    pub fn vips_buffer_dump_all();
}
extern "C" {
    pub fn vips_buffer_done(buffer: *mut VipsBuffer);
}
extern "C" {
    pub fn vips_buffer_undone(buffer: *mut VipsBuffer);
}
extern "C" {
    pub fn vips_buffer_unref(buffer: *mut VipsBuffer);
}
extern "C" {
    pub fn vips_buffer_new(im: *mut _VipsImage, area: *mut VipsRect) -> *mut VipsBuffer;
}
extern "C" {
    pub fn vips_buffer_ref(im: *mut _VipsImage, area: *mut VipsRect) -> *mut VipsBuffer;
}
extern "C" {
    pub fn vips_buffer_unref_ref(
        buffer: *mut VipsBuffer,
        im: *mut _VipsImage,
        area: *mut VipsRect,
    ) -> *mut VipsBuffer;
}
extern "C" {
    pub fn vips_buffer_print(buffer: *mut VipsBuffer);
}
extern "C" {
    pub fn vips__render_shutdown();
}
pub const _RegionType_VIPS_REGION_NONE: _RegionType = 0;
pub const _RegionType_VIPS_REGION_BUFFER: _RegionType = 1;
pub const _RegionType_VIPS_REGION_OTHER_REGION: _RegionType = 2;
pub const _RegionType_VIPS_REGION_OTHER_IMAGE: _RegionType = 3;
pub const _RegionType_VIPS_REGION_WINDOW: _RegionType = 4;
pub type _RegionType = u32;
pub use self::_RegionType as RegionType;
extern "C" {
    pub fn vips__region_take_ownership(reg: *mut _VipsRegion);
}
extern "C" {
    pub fn vips__region_check_ownership(reg: *mut _VipsRegion);
}
extern "C" {
    pub fn vips__region_no_ownership(reg: *mut _VipsRegion);
}
pub type VipsRegionFillFn = ::std::option::Option<
    unsafe extern "C" fn(
        arg1: *mut _VipsRegion,
        arg2: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
>;
extern "C" {
    pub fn vips_region_fill(
        reg: *mut _VipsRegion,
        r: *const VipsRect,
        fn_: VipsRegionFillFn,
        a: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips__image_wio_output(image: *mut _VipsImage) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips__image_pio_output(image: *mut _VipsImage) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips__argument_get_instance(
        argument_class: *mut VipsArgumentClass,
        object: *mut VipsObject,
    ) -> *mut VipsArgumentInstance;
}
extern "C" {
    pub fn vips__argument_table_lookup(
        table: *mut VipsArgumentTable,
        pspec: *mut GParamSpec,
    ) -> *mut VipsArgument;
}
extern "C" {
    pub fn vips__demand_hint_array(
        image: *mut _VipsImage,
        hint: ::std::os::raw::c_int,
        in_: *mut *mut _VipsImage,
    );
}
extern "C" {
    pub fn vips__image_copy_fields_array(
        out: *mut _VipsImage,
        in_: *mut *mut _VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips__region_count_pixels(
        region: *mut _VipsRegion,
        nickname: *const ::std::os::raw::c_char,
    );
}
extern "C" {
    pub fn vips_region_dump_all();
}
extern "C" {
    pub fn vips__init(argv0: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips__get_sizeof_vipsobject() -> usize;
}
extern "C" {
    pub fn vips_region_prepare_many(
        reg: *mut *mut _VipsRegion,
        r: *const VipsRect,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips__view_image(image: *mut _VipsImage) -> ::std::os::raw::c_int;
}
pub const VipsDemandStyle_VIPS_DEMAND_STYLE_ERROR: VipsDemandStyle = -1;
pub const VipsDemandStyle_VIPS_DEMAND_STYLE_SMALLTILE: VipsDemandStyle = 0;
pub const VipsDemandStyle_VIPS_DEMAND_STYLE_FATSTRIP: VipsDemandStyle = 1;
pub const VipsDemandStyle_VIPS_DEMAND_STYLE_THINSTRIP: VipsDemandStyle = 2;
pub const VipsDemandStyle_VIPS_DEMAND_STYLE_ANY: VipsDemandStyle = 3;
pub type VipsDemandStyle = i32;
pub const VipsImageType_VIPS_IMAGE_ERROR: VipsImageType = -1;
pub const VipsImageType_VIPS_IMAGE_NONE: VipsImageType = 0;
pub const VipsImageType_VIPS_IMAGE_SETBUF: VipsImageType = 1;
pub const VipsImageType_VIPS_IMAGE_SETBUF_FOREIGN: VipsImageType = 2;
pub const VipsImageType_VIPS_IMAGE_OPENIN: VipsImageType = 3;
pub const VipsImageType_VIPS_IMAGE_MMAPIN: VipsImageType = 4;
pub const VipsImageType_VIPS_IMAGE_MMAPINRW: VipsImageType = 5;
pub const VipsImageType_VIPS_IMAGE_OPENOUT: VipsImageType = 6;
pub const VipsImageType_VIPS_IMAGE_PARTIAL: VipsImageType = 7;
pub type VipsImageType = i32;
pub const VipsInterpretation_VIPS_INTERPRETATION_ERROR: VipsInterpretation = -1;
pub const VipsInterpretation_VIPS_INTERPRETATION_MULTIBAND: VipsInterpretation = 0;
pub const VipsInterpretation_VIPS_INTERPRETATION_B_W: VipsInterpretation = 1;
pub const VipsInterpretation_VIPS_INTERPRETATION_HISTOGRAM: VipsInterpretation = 10;
pub const VipsInterpretation_VIPS_INTERPRETATION_XYZ: VipsInterpretation = 12;
pub const VipsInterpretation_VIPS_INTERPRETATION_LAB: VipsInterpretation = 13;
pub const VipsInterpretation_VIPS_INTERPRETATION_CMYK: VipsInterpretation = 15;
pub const VipsInterpretation_VIPS_INTERPRETATION_LABQ: VipsInterpretation = 16;
pub const VipsInterpretation_VIPS_INTERPRETATION_RGB: VipsInterpretation = 17;
pub const VipsInterpretation_VIPS_INTERPRETATION_CMC: VipsInterpretation = 18;
pub const VipsInterpretation_VIPS_INTERPRETATION_LCH: VipsInterpretation = 19;
pub const VipsInterpretation_VIPS_INTERPRETATION_LABS: VipsInterpretation = 21;
pub const VipsInterpretation_VIPS_INTERPRETATION_sRGB: VipsInterpretation = 22;
pub const VipsInterpretation_VIPS_INTERPRETATION_YXY: VipsInterpretation = 23;
pub const VipsInterpretation_VIPS_INTERPRETATION_FOURIER: VipsInterpretation = 24;
pub const VipsInterpretation_VIPS_INTERPRETATION_RGB16: VipsInterpretation = 25;
pub const VipsInterpretation_VIPS_INTERPRETATION_GREY16: VipsInterpretation = 26;
pub const VipsInterpretation_VIPS_INTERPRETATION_MATRIX: VipsInterpretation = 27;
pub const VipsInterpretation_VIPS_INTERPRETATION_scRGB: VipsInterpretation = 28;
pub const VipsInterpretation_VIPS_INTERPRETATION_HSV: VipsInterpretation = 29;
pub const VipsInterpretation_VIPS_INTERPRETATION_LAST: VipsInterpretation = 30;
pub type VipsInterpretation = i32;
pub const VipsBandFormat_VIPS_FORMAT_NOTSET: VipsBandFormat = -1;
pub const VipsBandFormat_VIPS_FORMAT_UCHAR: VipsBandFormat = 0;
pub const VipsBandFormat_VIPS_FORMAT_CHAR: VipsBandFormat = 1;
pub const VipsBandFormat_VIPS_FORMAT_USHORT: VipsBandFormat = 2;
pub const VipsBandFormat_VIPS_FORMAT_SHORT: VipsBandFormat = 3;
pub const VipsBandFormat_VIPS_FORMAT_UINT: VipsBandFormat = 4;
pub const VipsBandFormat_VIPS_FORMAT_INT: VipsBandFormat = 5;
pub const VipsBandFormat_VIPS_FORMAT_FLOAT: VipsBandFormat = 6;
pub const VipsBandFormat_VIPS_FORMAT_COMPLEX: VipsBandFormat = 7;
pub const VipsBandFormat_VIPS_FORMAT_DOUBLE: VipsBandFormat = 8;
pub const VipsBandFormat_VIPS_FORMAT_DPCOMPLEX: VipsBandFormat = 9;
pub const VipsBandFormat_VIPS_FORMAT_LAST: VipsBandFormat = 10;
pub type VipsBandFormat = i32;
pub const VipsCoding_VIPS_CODING_ERROR: VipsCoding = -1;
pub const VipsCoding_VIPS_CODING_NONE: VipsCoding = 0;
pub const VipsCoding_VIPS_CODING_LABQ: VipsCoding = 2;
pub const VipsCoding_VIPS_CODING_RAD: VipsCoding = 6;
pub const VipsCoding_VIPS_CODING_LAST: VipsCoding = 7;
pub type VipsCoding = i32;
pub const VipsAccess_VIPS_ACCESS_RANDOM: VipsAccess = 0;
pub const VipsAccess_VIPS_ACCESS_SEQUENTIAL: VipsAccess = 1;
pub const VipsAccess_VIPS_ACCESS_SEQUENTIAL_UNBUFFERED: VipsAccess = 2;
pub const VipsAccess_VIPS_ACCESS_LAST: VipsAccess = 3;
pub type VipsAccess = u32;
pub type VipsStartFn = ::std::option::Option<
    unsafe extern "C" fn(
        out: *mut _VipsImage,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void,
>;
pub type VipsGenerateFn = ::std::option::Option<
    unsafe extern "C" fn(
        out: *mut _VipsRegion,
        seq: *mut ::std::os::raw::c_void,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
        stop: *mut gboolean,
    ) -> ::std::os::raw::c_int,
>;
pub type VipsStopFn = ::std::option::Option<
    unsafe extern "C" fn(
        seq: *mut ::std::os::raw::c_void,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsProgress {
    pub im: *mut _VipsImage,
    pub run: ::std::os::raw::c_int,
    pub eta: ::std::os::raw::c_int,
    pub tpels: gint64,
    pub npels: gint64,
    pub percent: ::std::os::raw::c_int,
    pub start: *mut GTimer,
}
#[test]
fn bindgen_test_layout__VipsProgress() {
    assert_eq!(
        ::std::mem::size_of::<_VipsProgress>(),
        48usize,
        concat!("Size of: ", stringify!(_VipsProgress))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsProgress>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsProgress))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsProgress>())).im as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsProgress),
            "::",
            stringify!(im)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsProgress>())).run as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsProgress),
            "::",
            stringify!(run)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsProgress>())).eta as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsProgress),
            "::",
            stringify!(eta)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsProgress>())).tpels as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsProgress),
            "::",
            stringify!(tpels)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsProgress>())).npels as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsProgress),
            "::",
            stringify!(npels)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsProgress>())).percent as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsProgress),
            "::",
            stringify!(percent)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsProgress>())).start as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsProgress),
            "::",
            stringify!(start)
        )
    );
}
pub type VipsProgress = _VipsProgress;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsImage {
    pub parent_instance: VipsObject,
    pub Xsize: ::std::os::raw::c_int,
    pub Ysize: ::std::os::raw::c_int,
    pub Bands: ::std::os::raw::c_int,
    pub BandFmt: VipsBandFormat,
    pub Coding: VipsCoding,
    pub Type: VipsInterpretation,
    pub Xres: f64,
    pub Yres: f64,
    pub Xoffset: ::std::os::raw::c_int,
    pub Yoffset: ::std::os::raw::c_int,
    pub Length: ::std::os::raw::c_int,
    pub Compression: ::std::os::raw::c_short,
    pub Level: ::std::os::raw::c_short,
    pub Bbits: ::std::os::raw::c_int,
    pub time: *mut VipsProgress,
    pub Hist: *mut ::std::os::raw::c_char,
    pub filename: *mut ::std::os::raw::c_char,
    pub data: *mut VipsPel,
    pub kill: ::std::os::raw::c_int,
    pub Xres_float: f32,
    pub Yres_float: f32,
    pub mode: *mut ::std::os::raw::c_char,
    pub dtype: VipsImageType,
    pub fd: ::std::os::raw::c_int,
    pub baseaddr: *mut ::std::os::raw::c_void,
    pub length: usize,
    pub magic: guint32,
    pub start_fn: VipsStartFn,
    pub generate_fn: VipsGenerateFn,
    pub stop_fn: VipsStopFn,
    pub client1: *mut ::std::os::raw::c_void,
    pub client2: *mut ::std::os::raw::c_void,
    pub sslock: *mut GMutex,
    pub regions: *mut GSList,
    pub dhint: VipsDemandStyle,
    pub meta: *mut GHashTable,
    pub meta_traverse: *mut GSList,
    pub sizeof_header: gint64,
    pub windows: *mut GSList,
    pub upstream: *mut GSList,
    pub downstream: *mut GSList,
    pub serial: ::std::os::raw::c_int,
    pub history_list: *mut GSList,
    pub progress_signal: *mut _VipsImage,
    pub file_length: gint64,
    pub hint_set: gboolean,
    pub delete_on_close: gboolean,
    pub delete_on_close_filename: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__VipsImage() {
    assert_eq!(
        ::std::mem::size_of::<_VipsImage>(),
        392usize,
        concat!("Size of: ", stringify!(_VipsImage))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsImage>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsImage))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).parent_instance as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(parent_instance)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).Xsize as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(Xsize)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).Ysize as *const _ as usize },
        84usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(Ysize)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).Bands as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(Bands)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).BandFmt as *const _ as usize },
        92usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(BandFmt)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).Coding as *const _ as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(Coding)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).Type as *const _ as usize },
        100usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(Type)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).Xres as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(Xres)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).Yres as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(Yres)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).Xoffset as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(Xoffset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).Yoffset as *const _ as usize },
        124usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(Yoffset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).Length as *const _ as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(Length)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).Compression as *const _ as usize },
        132usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(Compression)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).Level as *const _ as usize },
        134usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(Level)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).Bbits as *const _ as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(Bbits)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).time as *const _ as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(time)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).Hist as *const _ as usize },
        152usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(Hist)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).filename as *const _ as usize },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(filename)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).data as *const _ as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).kill as *const _ as usize },
        176usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(kill)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).Xres_float as *const _ as usize },
        180usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(Xres_float)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).Yres_float as *const _ as usize },
        184usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(Yres_float)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).mode as *const _ as usize },
        192usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(mode)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).dtype as *const _ as usize },
        200usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(dtype)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).fd as *const _ as usize },
        204usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(fd)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).baseaddr as *const _ as usize },
        208usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(baseaddr)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).length as *const _ as usize },
        216usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(length)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).magic as *const _ as usize },
        224usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(magic)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).start_fn as *const _ as usize },
        232usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(start_fn)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).generate_fn as *const _ as usize },
        240usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(generate_fn)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).stop_fn as *const _ as usize },
        248usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(stop_fn)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).client1 as *const _ as usize },
        256usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(client1)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).client2 as *const _ as usize },
        264usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(client2)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).sslock as *const _ as usize },
        272usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(sslock)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).regions as *const _ as usize },
        280usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(regions)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).dhint as *const _ as usize },
        288usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(dhint)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).meta as *const _ as usize },
        296usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(meta)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).meta_traverse as *const _ as usize },
        304usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(meta_traverse)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).sizeof_header as *const _ as usize },
        312usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(sizeof_header)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).windows as *const _ as usize },
        320usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(windows)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).upstream as *const _ as usize },
        328usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(upstream)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).downstream as *const _ as usize },
        336usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(downstream)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).serial as *const _ as usize },
        344usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(serial)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).history_list as *const _ as usize },
        352usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(history_list)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).progress_signal as *const _ as usize },
        360usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(progress_signal)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).file_length as *const _ as usize },
        368usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(file_length)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).hint_set as *const _ as usize },
        376usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(hint_set)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImage>())).delete_on_close as *const _ as usize },
        380usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(delete_on_close)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsImage>())).delete_on_close_filename as *const _ as usize
        },
        384usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImage),
            "::",
            stringify!(delete_on_close_filename)
        )
    );
}
pub type VipsImage = _VipsImage;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsImageClass {
    pub parent_class: VipsObjectClass,
    pub preeval: ::std::option::Option<
        unsafe extern "C" fn(image: *mut VipsImage, progress: *mut VipsProgress),
    >,
    pub eval: ::std::option::Option<
        unsafe extern "C" fn(image: *mut VipsImage, progress: *mut VipsProgress),
    >,
    pub posteval: ::std::option::Option<
        unsafe extern "C" fn(image: *mut VipsImage, progress: *mut VipsProgress),
    >,
    pub written: ::std::option::Option<
        unsafe extern "C" fn(image: *mut VipsImage, result: *mut ::std::os::raw::c_int),
    >,
    pub invalidate: ::std::option::Option<unsafe extern "C" fn(image: *mut VipsImage)>,
    pub minimise: ::std::option::Option<unsafe extern "C" fn(image: *mut VipsImage)>,
}
#[test]
fn bindgen_test_layout__VipsImageClass() {
    assert_eq!(
        ::std::mem::size_of::<_VipsImageClass>(),
        376usize,
        concat!("Size of: ", stringify!(_VipsImageClass))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsImageClass>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsImageClass))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImageClass>())).parent_class as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImageClass),
            "::",
            stringify!(parent_class)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImageClass>())).preeval as *const _ as usize },
        328usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImageClass),
            "::",
            stringify!(preeval)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImageClass>())).eval as *const _ as usize },
        336usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImageClass),
            "::",
            stringify!(eval)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImageClass>())).posteval as *const _ as usize },
        344usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImageClass),
            "::",
            stringify!(posteval)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImageClass>())).written as *const _ as usize },
        352usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImageClass),
            "::",
            stringify!(written)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImageClass>())).invalidate as *const _ as usize },
        360usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImageClass),
            "::",
            stringify!(invalidate)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsImageClass>())).minimise as *const _ as usize },
        368usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsImageClass),
            "::",
            stringify!(minimise)
        )
    );
}
pub type VipsImageClass = _VipsImageClass;
extern "C" {
    pub fn vips_image_get_type() -> GType;
}
extern "C" {
    pub fn vips_progress_set(progress: gboolean);
}
extern "C" {
    pub fn vips_image_invalidate_all(image: *mut VipsImage);
}
extern "C" {
    pub fn vips_image_minimise_all(image: *mut VipsImage);
}
extern "C" {
    pub fn vips_image_set_progress(image: *mut VipsImage, progress: gboolean);
}
extern "C" {
    pub fn vips_image_iskilled(image: *mut VipsImage) -> gboolean;
}
extern "C" {
    pub fn vips_image_set_kill(image: *mut VipsImage, kill: gboolean);
}
extern "C" {
    pub fn vips_filename_get_filename(
        vips_filename: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_filename_get_options(
        vips_filename: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_image_new() -> *mut VipsImage;
}
extern "C" {
    pub fn vips_image_new_memory() -> *mut VipsImage;
}
extern "C" {
    pub fn vips_image_memory() -> *mut VipsImage;
}
extern "C" {
    pub fn vips_image_new_from_file(name: *const ::std::os::raw::c_char, ...) -> *mut VipsImage;
}
extern "C" {
    pub fn vips_image_new_from_file_RW(filename: *const ::std::os::raw::c_char) -> *mut VipsImage;
}
extern "C" {
    pub fn vips_image_new_from_file_raw(
        filename: *const ::std::os::raw::c_char,
        xsize: ::std::os::raw::c_int,
        ysize: ::std::os::raw::c_int,
        bands: ::std::os::raw::c_int,
        offset: guint64,
    ) -> *mut VipsImage;
}
extern "C" {
    pub fn vips_image_new_from_memory(
        data: *const ::std::os::raw::c_void,
        size: usize,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        bands: ::std::os::raw::c_int,
        format: VipsBandFormat,
    ) -> *mut VipsImage;
}
extern "C" {
    pub fn vips_image_new_from_memory_copy(
        data: *const ::std::os::raw::c_void,
        size: usize,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        bands: ::std::os::raw::c_int,
        format: VipsBandFormat,
    ) -> *mut VipsImage;
}
extern "C" {
    pub fn vips_image_new_from_buffer(
        buf: *const ::std::os::raw::c_void,
        len: usize,
        option_string: *const ::std::os::raw::c_char,
        ...
    ) -> *mut VipsImage;
}
extern "C" {
    pub fn vips_image_new_matrix(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
    ) -> *mut VipsImage;
}
extern "C" {
    pub fn vips_image_new_matrixv(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ...
    ) -> *mut VipsImage;
}
extern "C" {
    pub fn vips_image_new_matrix_from_array(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        array: *const f64,
        size: ::std::os::raw::c_int,
    ) -> *mut VipsImage;
}
extern "C" {
    pub fn vips_image_matrix_from_array(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        array: *const f64,
        size: ::std::os::raw::c_int,
    ) -> *mut VipsImage;
}
extern "C" {
    pub fn vips_image_new_from_image(
        image: *mut VipsImage,
        c: *const f64,
        n: ::std::os::raw::c_int,
    ) -> *mut VipsImage;
}
extern "C" {
    pub fn vips_image_new_from_image1(image: *mut VipsImage, c: f64) -> *mut VipsImage;
}
extern "C" {
    pub fn vips_image_set_delete_on_close(image: *mut VipsImage, delete_on_close: gboolean);
}
extern "C" {
    pub fn vips_get_disc_threshold() -> guint64;
}
extern "C" {
    pub fn vips_image_new_temp_file(format: *const ::std::os::raw::c_char) -> *mut VipsImage;
}
extern "C" {
    pub fn vips_image_write(image: *mut VipsImage, out: *mut VipsImage) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_write_to_file(
        image: *mut VipsImage,
        name: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_write_to_buffer(
        in_: *mut VipsImage,
        suffix: *const ::std::os::raw::c_char,
        buf: *mut *mut ::std::os::raw::c_void,
        size: *mut usize,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_write_to_memory(
        in_: *mut VipsImage,
        size: *mut usize,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_image_decode_predict(
        in_: *mut VipsImage,
        bands: *mut ::std::os::raw::c_int,
        format: *mut VipsBandFormat,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_decode(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_encode(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        coding: VipsCoding,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_isMSBfirst(image: *mut VipsImage) -> gboolean;
}
extern "C" {
    pub fn vips_image_isfile(image: *mut VipsImage) -> gboolean;
}
extern "C" {
    pub fn vips_image_ispartial(image: *mut VipsImage) -> gboolean;
}
extern "C" {
    pub fn vips_image_hasalpha(image: *mut VipsImage) -> gboolean;
}
extern "C" {
    pub fn vips_image_copy_memory(image: *mut VipsImage) -> *mut VipsImage;
}
extern "C" {
    pub fn vips_image_wio_input(image: *mut VipsImage) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_pio_input(image: *mut VipsImage) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_pio_output(image: *mut VipsImage) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_inplace(image: *mut VipsImage) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_write_prepare(image: *mut VipsImage) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_write_line(
        image: *mut VipsImage,
        ypos: ::std::os::raw::c_int,
        linebuffer: *mut VipsPel,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_band_format_isint(format: VipsBandFormat) -> gboolean;
}
extern "C" {
    pub fn vips_band_format_isuint(format: VipsBandFormat) -> gboolean;
}
extern "C" {
    pub fn vips_band_format_is8bit(format: VipsBandFormat) -> gboolean;
}
extern "C" {
    pub fn vips_band_format_isfloat(format: VipsBandFormat) -> gboolean;
}
extern "C" {
    pub fn vips_band_format_iscomplex(format: VipsBandFormat) -> gboolean;
}
extern "C" {
    pub fn vips_system(cmd_format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_array_image_new(
        array: *mut *mut VipsImage,
        n: ::std::os::raw::c_int,
    ) -> *mut VipsArrayImage;
}
extern "C" {
    pub fn vips_array_image_newv(n: ::std::os::raw::c_int, ...) -> *mut VipsArrayImage;
}
extern "C" {
    pub fn vips_array_image_new_from_string(
        string: *const ::std::os::raw::c_char,
        flags: VipsAccess,
    ) -> *mut VipsArrayImage;
}
extern "C" {
    pub fn vips_array_image_empty() -> *mut VipsArrayImage;
}
extern "C" {
    pub fn vips_array_image_append(
        array: *mut VipsArrayImage,
        image: *mut VipsImage,
    ) -> *mut VipsArrayImage;
}
extern "C" {
    pub fn vips_array_image_get(
        array: *mut VipsArrayImage,
        n: *mut ::std::os::raw::c_int,
    ) -> *mut *mut VipsImage;
}
extern "C" {
    pub fn vips_value_get_array_image(
        value: *const GValue,
        n: *mut ::std::os::raw::c_int,
    ) -> *mut *mut VipsImage;
}
extern "C" {
    pub fn vips_value_set_array_image(value: *mut GValue, n: ::std::os::raw::c_int);
}
extern "C" {
    pub fn vips_reorder_prepare_many(
        image: *mut VipsImage,
        regions: *mut *mut _VipsRegion,
        r: *mut VipsRect,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_reorder_margin_hint(image: *mut VipsImage, margin: ::std::os::raw::c_int);
}
extern "C" {
    pub fn vips_malloc(object: *mut VipsObject, size: usize) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_strdup(
        object: *mut VipsObject,
        str: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_free(buf: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_tracked_free(s: *mut ::std::os::raw::c_void);
}
extern "C" {
    pub fn vips_tracked_malloc(size: usize) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_tracked_get_mem() -> usize;
}
extern "C" {
    pub fn vips_tracked_get_mem_highwater() -> usize;
}
extern "C" {
    pub fn vips_tracked_get_allocs() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_tracked_open(
        pathname: *const ::std::os::raw::c_char,
        flags: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_tracked_close(fd: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_tracked_get_files() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_error_buffer() -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_error_clear();
}
extern "C" {
    pub fn vips_error_freeze();
}
extern "C" {
    pub fn vips_error_thaw();
}
extern "C" {
    pub fn vips_error(
        domain: *const ::std::os::raw::c_char,
        fmt: *const ::std::os::raw::c_char,
        ...
    );
}
extern "C" {
    pub fn vips_verror(
        domain: *const ::std::os::raw::c_char,
        fmt: *const ::std::os::raw::c_char,
        ap: *mut __va_list_tag,
    );
}
extern "C" {
    pub fn vips_error_system(
        err: ::std::os::raw::c_int,
        domain: *const ::std::os::raw::c_char,
        fmt: *const ::std::os::raw::c_char,
        ...
    );
}
extern "C" {
    pub fn vips_verror_system(
        err: ::std::os::raw::c_int,
        domain: *const ::std::os::raw::c_char,
        fmt: *const ::std::os::raw::c_char,
        ap: *mut __va_list_tag,
    );
}
extern "C" {
    pub fn vips_error_g(error: *mut *mut GError);
}
extern "C" {
    pub fn vips_g_error(error: *mut *mut GError);
}
extern "C" {
    pub fn vips_error_exit(fmt: *const ::std::os::raw::c_char, ...);
}
extern "C" {
    pub fn vips_check_uncoded(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_coding(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
        coding: VipsCoding,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_coding_known(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_coding_noneorlabq(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_coding_same(
        domain: *const ::std::os::raw::c_char,
        im1: *mut VipsImage,
        im2: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_mono(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_bands(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
        bands: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_bands_1or3(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_bands_atleast(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
        bands: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_bands_1orn(
        domain: *const ::std::os::raw::c_char,
        im1: *mut VipsImage,
        im2: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_bands_1orn_unary(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
        n: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_bands_same(
        domain: *const ::std::os::raw::c_char,
        im1: *mut VipsImage,
        im2: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_bandno(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
        bandno: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_int(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_uint(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_uintorf(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_noncomplex(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_complex(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_twocomponents(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_format(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
        fmt: VipsBandFormat,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_u8or16(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_8or16(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_u8or16orf(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_format_same(
        domain: *const ::std::os::raw::c_char,
        im1: *mut VipsImage,
        im2: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_size_same(
        domain: *const ::std::os::raw::c_char,
        im1: *mut VipsImage,
        im2: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_oddsquare(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_vector_length(
        domain: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
        len: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_vector(
        domain: *const ::std::os::raw::c_char,
        n: ::std::os::raw::c_int,
        im: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_hist(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_matrix(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
        out: *mut *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_separable(
        domain: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_check_precision_intfloat(
        domain: *const ::std::os::raw::c_char,
        precision: VipsPrecision,
    ) -> ::std::os::raw::c_int;
}
pub const VipsFormatFlags_VIPS_FORMAT_NONE: VipsFormatFlags = 0;
pub const VipsFormatFlags_VIPS_FORMAT_PARTIAL: VipsFormatFlags = 1;
pub const VipsFormatFlags_VIPS_FORMAT_BIGENDIAN: VipsFormatFlags = 2;
pub type VipsFormatFlags = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsFormat {
    pub parent_object: VipsObject,
}
#[test]
fn bindgen_test_layout__VipsFormat() {
    assert_eq!(
        ::std::mem::size_of::<_VipsFormat>(),
        80usize,
        concat!("Size of: ", stringify!(_VipsFormat))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsFormat>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsFormat))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsFormat>())).parent_object as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsFormat),
            "::",
            stringify!(parent_object)
        )
    );
}
pub type VipsFormat = _VipsFormat;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsFormatClass {
    pub parent_class: VipsObjectClass,
    pub is_a: ::std::option::Option<
        unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> gboolean,
    >,
    pub header: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *const ::std::os::raw::c_char,
            arg2: *mut VipsImage,
        ) -> ::std::os::raw::c_int,
    >,
    pub load: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *const ::std::os::raw::c_char,
            arg2: *mut VipsImage,
        ) -> ::std::os::raw::c_int,
    >,
    pub save: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut VipsImage,
            arg2: *const ::std::os::raw::c_char,
        ) -> ::std::os::raw::c_int,
    >,
    pub get_flags: ::std::option::Option<
        unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> VipsFormatFlags,
    >,
    pub priority: ::std::os::raw::c_int,
    pub suffs: *mut *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__VipsFormatClass() {
    assert_eq!(
        ::std::mem::size_of::<_VipsFormatClass>(),
        384usize,
        concat!("Size of: ", stringify!(_VipsFormatClass))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsFormatClass>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsFormatClass))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsFormatClass>())).parent_class as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsFormatClass),
            "::",
            stringify!(parent_class)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsFormatClass>())).is_a as *const _ as usize },
        328usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsFormatClass),
            "::",
            stringify!(is_a)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsFormatClass>())).header as *const _ as usize },
        336usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsFormatClass),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsFormatClass>())).load as *const _ as usize },
        344usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsFormatClass),
            "::",
            stringify!(load)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsFormatClass>())).save as *const _ as usize },
        352usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsFormatClass),
            "::",
            stringify!(save)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsFormatClass>())).get_flags as *const _ as usize },
        360usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsFormatClass),
            "::",
            stringify!(get_flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsFormatClass>())).priority as *const _ as usize },
        368usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsFormatClass),
            "::",
            stringify!(priority)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsFormatClass>())).suffs as *const _ as usize },
        376usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsFormatClass),
            "::",
            stringify!(suffs)
        )
    );
}
pub type VipsFormatClass = _VipsFormatClass;
extern "C" {
    pub fn vips_format_get_type() -> GType;
}
extern "C" {
    pub fn vips_format_map(
        fn_: VipsSListMap2Fn,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_format_for_file(filename: *const ::std::os::raw::c_char) -> *mut VipsFormatClass;
}
extern "C" {
    pub fn vips_format_for_name(filename: *const ::std::os::raw::c_char) -> *mut VipsFormatClass;
}
extern "C" {
    pub fn vips_format_get_flags(
        format: *mut VipsFormatClass,
        filename: *const ::std::os::raw::c_char,
    ) -> VipsFormatFlags;
}
extern "C" {
    pub fn vips_format_read(
        filename: *const ::std::os::raw::c_char,
        out: *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_format_write(
        in_: *mut VipsImage,
        filename: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
pub const VipsRegionShrink_VIPS_REGION_SHRINK_MEAN: VipsRegionShrink = 0;
pub const VipsRegionShrink_VIPS_REGION_SHRINK_MEDIAN: VipsRegionShrink = 1;
pub const VipsRegionShrink_VIPS_REGION_SHRINK_MODE: VipsRegionShrink = 2;
pub const VipsRegionShrink_VIPS_REGION_SHRINK_LAST: VipsRegionShrink = 3;
pub type VipsRegionShrink = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsRegion {
    pub parent_object: VipsObject,
    pub im: *mut VipsImage,
    pub valid: VipsRect,
    pub type_: RegionType,
    pub data: *mut VipsPel,
    pub bpl: ::std::os::raw::c_int,
    pub seq: *mut ::std::os::raw::c_void,
    pub thread: *mut GThread,
    pub window: *mut VipsWindow,
    pub buffer: *mut VipsBuffer,
    pub invalid: gboolean,
}
#[test]
fn bindgen_test_layout__VipsRegion() {
    assert_eq!(
        ::std::mem::size_of::<_VipsRegion>(),
        168usize,
        concat!("Size of: ", stringify!(_VipsRegion))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsRegion>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsRegion))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsRegion>())).parent_object as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsRegion),
            "::",
            stringify!(parent_object)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsRegion>())).im as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsRegion),
            "::",
            stringify!(im)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsRegion>())).valid as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsRegion),
            "::",
            stringify!(valid)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsRegion>())).type_ as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsRegion),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsRegion>())).data as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsRegion),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsRegion>())).bpl as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsRegion),
            "::",
            stringify!(bpl)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsRegion>())).seq as *const _ as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsRegion),
            "::",
            stringify!(seq)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsRegion>())).thread as *const _ as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsRegion),
            "::",
            stringify!(thread)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsRegion>())).window as *const _ as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsRegion),
            "::",
            stringify!(window)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsRegion>())).buffer as *const _ as usize },
        152usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsRegion),
            "::",
            stringify!(buffer)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsRegion>())).invalid as *const _ as usize },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsRegion),
            "::",
            stringify!(invalid)
        )
    );
}
pub type VipsRegion = _VipsRegion;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsRegionClass {
    pub parent_class: VipsObjectClass,
}
#[test]
fn bindgen_test_layout__VipsRegionClass() {
    assert_eq!(
        ::std::mem::size_of::<_VipsRegionClass>(),
        328usize,
        concat!("Size of: ", stringify!(_VipsRegionClass))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsRegionClass>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsRegionClass))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsRegionClass>())).parent_class as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsRegionClass),
            "::",
            stringify!(parent_class)
        )
    );
}
pub type VipsRegionClass = _VipsRegionClass;
extern "C" {
    pub fn vips_region_get_type() -> GType;
}
extern "C" {
    pub fn vips_region_new(image: *mut VipsImage) -> *mut VipsRegion;
}
extern "C" {
    pub fn vips_region_buffer(reg: *mut VipsRegion, r: *const VipsRect) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_region_image(reg: *mut VipsRegion, r: *const VipsRect) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_region_region(
        reg: *mut VipsRegion,
        dest: *mut VipsRegion,
        r: *const VipsRect,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_region_equalsregion(
        reg1: *mut VipsRegion,
        reg2: *mut VipsRegion,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_region_position(
        reg: *mut VipsRegion,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_region_paint(
        reg: *mut VipsRegion,
        r: *const VipsRect,
        value: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn vips_region_paint_pel(reg: *mut VipsRegion, r: *const VipsRect, ink: *const VipsPel);
}
extern "C" {
    pub fn vips_region_black(reg: *mut VipsRegion);
}
extern "C" {
    pub fn vips_region_copy(
        reg: *mut VipsRegion,
        dest: *mut VipsRegion,
        r: *const VipsRect,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn vips_region_shrink_method(
        from: *mut VipsRegion,
        to: *mut VipsRegion,
        target: *const VipsRect,
        method: VipsRegionShrink,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_region_shrink(
        from: *mut VipsRegion,
        to: *mut VipsRegion,
        target: *const VipsRect,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_region_prepare(reg: *mut VipsRegion, r: *const VipsRect) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_region_prepare_to(
        reg: *mut VipsRegion,
        dest: *mut VipsRegion,
        r: *const VipsRect,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_region_fetch(
        region: *mut VipsRegion,
        left: ::std::os::raw::c_int,
        top: ::std::os::raw::c_int,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        len: *mut usize,
    ) -> *mut VipsPel;
}
extern "C" {
    pub fn vips_region_width(region: *mut VipsRegion) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_region_height(region: *mut VipsRegion) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_region_invalidate(reg: *mut VipsRegion);
}
pub type VipsRegionWrite = ::std::option::Option<
    unsafe extern "C" fn(
        region: *mut VipsRegion,
        area: *mut VipsRect,
        a: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
>;
extern "C" {
    pub fn vips_sink_disc(
        im: *mut VipsImage,
        write_fn: VipsRegionWrite,
        a: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_sink(
        im: *mut VipsImage,
        start_fn: VipsStartFn,
        generate_fn: VipsGenerateFn,
        stop_fn: VipsStopFn,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_sink_tile(
        im: *mut VipsImage,
        tile_width: ::std::os::raw::c_int,
        tile_height: ::std::os::raw::c_int,
        start_fn: VipsStartFn,
        generate_fn: VipsGenerateFn,
        stop_fn: VipsStopFn,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
pub type VipsSinkNotify = ::std::option::Option<
    unsafe extern "C" fn(im: *mut VipsImage, rect: *mut VipsRect, a: *mut ::std::os::raw::c_void),
>;
extern "C" {
    pub fn vips_sink_screen(
        in_: *mut VipsImage,
        out: *mut VipsImage,
        mask: *mut VipsImage,
        tile_width: ::std::os::raw::c_int,
        tile_height: ::std::os::raw::c_int,
        max_tiles: ::std::os::raw::c_int,
        priority: ::std::os::raw::c_int,
        notify_fn: VipsSinkNotify,
        a: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_sink_memory(im: *mut VipsImage) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_start_one(
        out: *mut VipsImage,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_stop_one(
        seq: *mut ::std::os::raw::c_void,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_start_many(
        out: *mut VipsImage,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_stop_many(
        seq: *mut ::std::os::raw::c_void,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_allocate_input_array(out: *mut VipsImage, ...) -> *mut *mut VipsImage;
}
extern "C" {
    pub fn vips_image_generate(
        image: *mut VipsImage,
        start_fn: VipsStartFn,
        generate_fn: VipsGenerateFn,
        stop_fn: VipsStopFn,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_pipeline_array(
        image: *mut VipsImage,
        hint: VipsDemandStyle,
        in_: *mut *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_pipelinev(
        image: *mut VipsImage,
        hint: VipsDemandStyle,
        ...
    ) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsInterpolate {
    pub parent_object: VipsObject,
}
#[test]
fn bindgen_test_layout__VipsInterpolate() {
    assert_eq!(
        ::std::mem::size_of::<_VipsInterpolate>(),
        80usize,
        concat!("Size of: ", stringify!(_VipsInterpolate))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsInterpolate>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsInterpolate))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsInterpolate>())).parent_object as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsInterpolate),
            "::",
            stringify!(parent_object)
        )
    );
}
pub type VipsInterpolate = _VipsInterpolate;
pub type VipsInterpolateMethod = ::std::option::Option<
    unsafe extern "C" fn(
        interpolate: *mut VipsInterpolate,
        out: *mut ::std::os::raw::c_void,
        in_: *mut VipsRegion,
        x: f64,
        y: f64,
    ),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsInterpolateClass {
    pub parent_class: VipsObjectClass,
    pub interpolate: VipsInterpolateMethod,
    pub get_window_size: ::std::option::Option<
        unsafe extern "C" fn(interpolate: *mut VipsInterpolate) -> ::std::os::raw::c_int,
    >,
    pub window_size: ::std::os::raw::c_int,
    pub get_window_offset: ::std::option::Option<
        unsafe extern "C" fn(interpolate: *mut VipsInterpolate) -> ::std::os::raw::c_int,
    >,
    pub window_offset: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__VipsInterpolateClass() {
    assert_eq!(
        ::std::mem::size_of::<_VipsInterpolateClass>(),
        368usize,
        concat!("Size of: ", stringify!(_VipsInterpolateClass))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsInterpolateClass>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsInterpolateClass))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsInterpolateClass>())).parent_class as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsInterpolateClass),
            "::",
            stringify!(parent_class)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsInterpolateClass>())).interpolate as *const _ as usize
        },
        328usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsInterpolateClass),
            "::",
            stringify!(interpolate)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsInterpolateClass>())).get_window_size as *const _ as usize
        },
        336usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsInterpolateClass),
            "::",
            stringify!(get_window_size)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsInterpolateClass>())).window_size as *const _ as usize
        },
        344usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsInterpolateClass),
            "::",
            stringify!(window_size)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsInterpolateClass>())).get_window_offset as *const _ as usize
        },
        352usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsInterpolateClass),
            "::",
            stringify!(get_window_offset)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsInterpolateClass>())).window_offset as *const _ as usize
        },
        360usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsInterpolateClass),
            "::",
            stringify!(window_offset)
        )
    );
}
pub type VipsInterpolateClass = _VipsInterpolateClass;
extern "C" {
    pub fn vips_interpolate_get_type() -> GType;
}
extern "C" {
    pub fn vips_interpolate(
        interpolate: *mut VipsInterpolate,
        out: *mut ::std::os::raw::c_void,
        in_: *mut VipsRegion,
        x: f64,
        y: f64,
    );
}
extern "C" {
    pub fn vips_interpolate_get_method(interpolate: *mut VipsInterpolate) -> VipsInterpolateMethod;
}
extern "C" {
    pub fn vips_interpolate_get_window_size(
        interpolate: *mut VipsInterpolate,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_interpolate_get_window_offset(
        interpolate: *mut VipsInterpolate,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_interpolate_nearest_static() -> *mut VipsInterpolate;
}
extern "C" {
    pub fn vips_interpolate_bilinear_static() -> *mut VipsInterpolate;
}
extern "C" {
    pub fn vips_interpolate_new(nickname: *const ::std::os::raw::c_char) -> *mut VipsInterpolate;
}
extern "C" {
    pub fn vips_g_mutex_new() -> *mut GMutex;
}
extern "C" {
    pub fn vips_g_mutex_free(arg1: *mut GMutex);
}
extern "C" {
    pub fn vips_g_cond_new() -> *mut GCond;
}
extern "C" {
    pub fn vips_g_cond_free(arg1: *mut GCond);
}
extern "C" {
    pub fn vips_g_thread_new(
        arg1: *const ::std::os::raw::c_char,
        arg2: GThreadFunc,
        arg3: gpointer,
    ) -> *mut GThread;
}
extern "C" {
    pub fn vips_g_thread_join(thread: *mut GThread) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_thread_isworker() -> gboolean;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct VipsSemaphore {
    pub name: *mut ::std::os::raw::c_char,
    pub v: ::std::os::raw::c_int,
    pub mutex: *mut GMutex,
    pub cond: *mut GCond,
}
#[test]
fn bindgen_test_layout_VipsSemaphore() {
    assert_eq!(
        ::std::mem::size_of::<VipsSemaphore>(),
        32usize,
        concat!("Size of: ", stringify!(VipsSemaphore))
    );
    assert_eq!(
        ::std::mem::align_of::<VipsSemaphore>(),
        8usize,
        concat!("Alignment of ", stringify!(VipsSemaphore))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<VipsSemaphore>())).name as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(VipsSemaphore),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<VipsSemaphore>())).v as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(VipsSemaphore),
            "::",
            stringify!(v)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<VipsSemaphore>())).mutex as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(VipsSemaphore),
            "::",
            stringify!(mutex)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<VipsSemaphore>())).cond as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(VipsSemaphore),
            "::",
            stringify!(cond)
        )
    );
}
extern "C" {
    pub fn vips_semaphore_up(s: *mut VipsSemaphore) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_semaphore_down(s: *mut VipsSemaphore) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_semaphore_upn(
        s: *mut VipsSemaphore,
        n: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_semaphore_downn(
        s: *mut VipsSemaphore,
        n: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_semaphore_destroy(s: *mut VipsSemaphore);
}
extern "C" {
    pub fn vips_semaphore_init(
        s: *mut VipsSemaphore,
        v: ::std::os::raw::c_int,
        name: *mut ::std::os::raw::c_char,
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsThreadState {
    pub parent_object: VipsObject,
    pub im: *mut VipsImage,
    pub reg: *mut VipsRegion,
    pub pos: VipsRect,
    pub x: ::std::os::raw::c_int,
    pub y: ::std::os::raw::c_int,
    pub stop: gboolean,
    pub a: *mut ::std::os::raw::c_void,
    pub stall: gboolean,
}
#[test]
fn bindgen_test_layout__VipsThreadState() {
    assert_eq!(
        ::std::mem::size_of::<_VipsThreadState>(),
        144usize,
        concat!("Size of: ", stringify!(_VipsThreadState))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsThreadState>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsThreadState))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsThreadState>())).parent_object as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsThreadState),
            "::",
            stringify!(parent_object)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsThreadState>())).im as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsThreadState),
            "::",
            stringify!(im)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsThreadState>())).reg as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsThreadState),
            "::",
            stringify!(reg)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsThreadState>())).pos as *const _ as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsThreadState),
            "::",
            stringify!(pos)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsThreadState>())).x as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsThreadState),
            "::",
            stringify!(x)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsThreadState>())).y as *const _ as usize },
        116usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsThreadState),
            "::",
            stringify!(y)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsThreadState>())).stop as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsThreadState),
            "::",
            stringify!(stop)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsThreadState>())).a as *const _ as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsThreadState),
            "::",
            stringify!(a)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsThreadState>())).stall as *const _ as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsThreadState),
            "::",
            stringify!(stall)
        )
    );
}
pub type VipsThreadState = _VipsThreadState;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsThreadStateClass {
    pub parent_class: VipsObjectClass,
}
#[test]
fn bindgen_test_layout__VipsThreadStateClass() {
    assert_eq!(
        ::std::mem::size_of::<_VipsThreadStateClass>(),
        328usize,
        concat!("Size of: ", stringify!(_VipsThreadStateClass))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsThreadStateClass>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsThreadStateClass))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsThreadStateClass>())).parent_class as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsThreadStateClass),
            "::",
            stringify!(parent_class)
        )
    );
}
pub type VipsThreadStateClass = _VipsThreadStateClass;
extern "C" {
    pub fn vips_thread_state_set(
        object: *mut VipsObject,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_thread_state_get_type() -> GType;
}
extern "C" {
    pub fn vips_thread_state_new(
        im: *mut VipsImage,
        a: *mut ::std::os::raw::c_void,
    ) -> *mut VipsThreadState;
}
pub type VipsThreadStartFn = ::std::option::Option<
    unsafe extern "C" fn(
        im: *mut VipsImage,
        a: *mut ::std::os::raw::c_void,
    ) -> *mut VipsThreadState,
>;
pub type VipsThreadpoolAllocateFn = ::std::option::Option<
    unsafe extern "C" fn(
        state: *mut VipsThreadState,
        a: *mut ::std::os::raw::c_void,
        stop: *mut gboolean,
    ) -> ::std::os::raw::c_int,
>;
pub type VipsThreadpoolWorkFn = ::std::option::Option<
    unsafe extern "C" fn(
        state: *mut VipsThreadState,
        a: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
>;
pub type VipsThreadpoolProgressFn = ::std::option::Option<
    unsafe extern "C" fn(a: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
>;
extern "C" {
    pub fn vips_threadpool_run(
        im: *mut VipsImage,
        start: VipsThreadStartFn,
        allocate: VipsThreadpoolAllocateFn,
        work: VipsThreadpoolWorkFn,
        progress: VipsThreadpoolProgressFn,
        a: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_get_tile_size(
        im: *mut VipsImage,
        tile_width: *mut ::std::os::raw::c_int,
        tile_height: *mut ::std::os::raw::c_int,
        n_lines: *mut ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn vips_format_sizeof(format: VipsBandFormat) -> guint64;
}
extern "C" {
    pub fn vips_format_sizeof_unsafe(format: VipsBandFormat) -> guint64;
}
extern "C" {
    pub fn vips_image_get_width(image: *const VipsImage) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_get_height(image: *const VipsImage) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_get_bands(image: *const VipsImage) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_get_format(image: *const VipsImage) -> VipsBandFormat;
}
extern "C" {
    pub fn vips_image_guess_format(image: *const VipsImage) -> VipsBandFormat;
}
extern "C" {
    pub fn vips_image_get_coding(image: *const VipsImage) -> VipsCoding;
}
extern "C" {
    pub fn vips_image_get_interpretation(image: *const VipsImage) -> VipsInterpretation;
}
extern "C" {
    pub fn vips_image_guess_interpretation(image: *const VipsImage) -> VipsInterpretation;
}
extern "C" {
    pub fn vips_image_get_xres(image: *const VipsImage) -> f64;
}
extern "C" {
    pub fn vips_image_get_yres(image: *const VipsImage) -> f64;
}
extern "C" {
    pub fn vips_image_get_xoffset(image: *const VipsImage) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_get_yoffset(image: *const VipsImage) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_get_filename(image: *const VipsImage) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_image_get_mode(image: *const VipsImage) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_image_get_scale(image: *const VipsImage) -> f64;
}
extern "C" {
    pub fn vips_image_get_offset(image: *const VipsImage) -> f64;
}
extern "C" {
    pub fn vips_image_get_page_height(image: *mut VipsImage) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_get_n_pages(image: *mut VipsImage) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_get_data(image: *mut VipsImage) -> *const ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_image_init_fields(
        image: *mut VipsImage,
        xsize: ::std::os::raw::c_int,
        ysize: ::std::os::raw::c_int,
        bands: ::std::os::raw::c_int,
        format: VipsBandFormat,
        coding: VipsCoding,
        interpretation: VipsInterpretation,
        xres: f64,
        yres: f64,
    );
}
extern "C" {
    pub fn vips_image_set(
        image: *mut VipsImage,
        name: *const ::std::os::raw::c_char,
        value: *mut GValue,
    );
}
extern "C" {
    pub fn vips_image_get(
        image: *const VipsImage,
        name: *const ::std::os::raw::c_char,
        value_copy: *mut GValue,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_get_as_string(
        image: *const VipsImage,
        name: *const ::std::os::raw::c_char,
        out: *mut *mut ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_get_typeof(
        image: *const VipsImage,
        name: *const ::std::os::raw::c_char,
    ) -> GType;
}
extern "C" {
    pub fn vips_image_remove(
        image: *mut VipsImage,
        name: *const ::std::os::raw::c_char,
    ) -> gboolean;
}
pub type VipsImageMapFn = ::std::option::Option<
    unsafe extern "C" fn(
        image: *mut VipsImage,
        name: *const ::std::os::raw::c_char,
        value: *mut GValue,
        a: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void,
>;
extern "C" {
    pub fn vips_image_map(
        image: *mut VipsImage,
        fn_: VipsImageMapFn,
        a: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn vips_image_get_fields(image: *mut VipsImage) -> *mut *mut gchar;
}
extern "C" {
    pub fn vips_image_set_area(
        image: *mut VipsImage,
        name: *const ::std::os::raw::c_char,
        free_fn: VipsCallbackFn,
        data: *mut ::std::os::raw::c_void,
    );
}
extern "C" {
    pub fn vips_image_get_area(
        image: *const VipsImage,
        name: *const ::std::os::raw::c_char,
        data: *mut *const ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_set_blob(
        image: *mut VipsImage,
        name: *const ::std::os::raw::c_char,
        free_fn: VipsCallbackFn,
        data: *const ::std::os::raw::c_void,
        length: usize,
    );
}
extern "C" {
    pub fn vips_image_set_blob_copy(
        image: *mut VipsImage,
        name: *const ::std::os::raw::c_char,
        data: *const ::std::os::raw::c_void,
        length: usize,
    );
}
extern "C" {
    pub fn vips_image_get_blob(
        image: *const VipsImage,
        name: *const ::std::os::raw::c_char,
        data: *mut *const ::std::os::raw::c_void,
        length: *mut usize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_get_int(
        image: *const VipsImage,
        name: *const ::std::os::raw::c_char,
        out: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_set_int(
        image: *mut VipsImage,
        name: *const ::std::os::raw::c_char,
        i: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn vips_image_get_double(
        image: *const VipsImage,
        name: *const ::std::os::raw::c_char,
        out: *mut f64,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_set_double(
        image: *mut VipsImage,
        name: *const ::std::os::raw::c_char,
        d: f64,
    );
}
extern "C" {
    pub fn vips_image_get_string(
        image: *const VipsImage,
        name: *const ::std::os::raw::c_char,
        out: *mut *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_set_string(
        image: *mut VipsImage,
        name: *const ::std::os::raw::c_char,
        str: *const ::std::os::raw::c_char,
    );
}
extern "C" {
    pub fn vips_image_print_field(image: *const VipsImage, field: *const ::std::os::raw::c_char);
}
extern "C" {
    pub fn vips_image_get_image(
        image: *const VipsImage,
        name: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_set_image(
        image: *mut VipsImage,
        name: *const ::std::os::raw::c_char,
        im: *mut VipsImage,
    );
}
extern "C" {
    pub fn vips_image_history_printf(
        image: *mut VipsImage,
        format: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_history_args(
        image: *mut VipsImage,
        name: *const ::std::os::raw::c_char,
        argc: ::std::os::raw::c_int,
        argv: *mut *mut ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_image_get_history(image: *mut VipsImage) -> *const ::std::os::raw::c_char;
}
pub const VipsOperationFlags_VIPS_OPERATION_NONE: VipsOperationFlags = 0;
pub const VipsOperationFlags_VIPS_OPERATION_SEQUENTIAL: VipsOperationFlags = 1;
pub const VipsOperationFlags_VIPS_OPERATION_SEQUENTIAL_UNBUFFERED: VipsOperationFlags = 2;
pub const VipsOperationFlags_VIPS_OPERATION_NOCACHE: VipsOperationFlags = 4;
pub const VipsOperationFlags_VIPS_OPERATION_DEPRECATED: VipsOperationFlags = 8;
pub type VipsOperationFlags = u32;
pub type VipsOperationBuildFn =
    ::std::option::Option<unsafe extern "C" fn(object: *mut VipsObject) -> gboolean>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsOperation {
    pub parent_instance: VipsObject,
    pub hash: guint,
    pub found_hash: gboolean,
    pub pixels: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__VipsOperation() {
    assert_eq!(
        ::std::mem::size_of::<_VipsOperation>(),
        96usize,
        concat!("Size of: ", stringify!(_VipsOperation))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsOperation>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsOperation))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsOperation>())).parent_instance as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsOperation),
            "::",
            stringify!(parent_instance)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsOperation>())).hash as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsOperation),
            "::",
            stringify!(hash)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsOperation>())).found_hash as *const _ as usize },
        84usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsOperation),
            "::",
            stringify!(found_hash)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsOperation>())).pixels as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsOperation),
            "::",
            stringify!(pixels)
        )
    );
}
pub type VipsOperation = _VipsOperation;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsOperationClass {
    pub parent_class: VipsObjectClass,
    pub usage: ::std::option::Option<
        unsafe extern "C" fn(cls: *mut _VipsOperationClass, buf: *mut VipsBuf),
    >,
    pub get_flags: ::std::option::Option<
        unsafe extern "C" fn(operation: *mut VipsOperation) -> VipsOperationFlags,
    >,
    pub flags: VipsOperationFlags,
    pub invalidate: ::std::option::Option<unsafe extern "C" fn(operation: *mut VipsOperation)>,
}
#[test]
fn bindgen_test_layout__VipsOperationClass() {
    assert_eq!(
        ::std::mem::size_of::<_VipsOperationClass>(),
        360usize,
        concat!("Size of: ", stringify!(_VipsOperationClass))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsOperationClass>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsOperationClass))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsOperationClass>())).parent_class as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsOperationClass),
            "::",
            stringify!(parent_class)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsOperationClass>())).usage as *const _ as usize },
        328usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsOperationClass),
            "::",
            stringify!(usage)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsOperationClass>())).get_flags as *const _ as usize },
        336usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsOperationClass),
            "::",
            stringify!(get_flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsOperationClass>())).flags as *const _ as usize },
        344usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsOperationClass),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsOperationClass>())).invalidate as *const _ as usize },
        352usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsOperationClass),
            "::",
            stringify!(invalidate)
        )
    );
}
pub type VipsOperationClass = _VipsOperationClass;
extern "C" {
    pub fn vips_operation_get_type() -> GType;
}
extern "C" {
    pub fn vips_operation_get_flags(operation: *mut VipsOperation) -> VipsOperationFlags;
}
extern "C" {
    pub fn vips_operation_class_print_usage(operation_class: *mut VipsOperationClass);
}
extern "C" {
    pub fn vips_operation_invalidate(operation: *mut VipsOperation);
}
extern "C" {
    pub fn vips_operation_call_valist(
        operation: *mut VipsOperation,
        ap: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_operation_new(name: *const ::std::os::raw::c_char) -> *mut VipsOperation;
}
extern "C" {
    pub fn vips_call_required_optional(
        operation: *mut *mut VipsOperation,
        required: *mut __va_list_tag,
        optional: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_call(operation_name: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_call_split(
        operation_name: *const ::std::os::raw::c_char,
        optional: *mut __va_list_tag,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_call_split_option_string(
        operation_name: *const ::std::os::raw::c_char,
        option_string: *const ::std::os::raw::c_char,
        optional: *mut __va_list_tag,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_call_options(group: *mut GOptionGroup, operation: *mut VipsOperation);
}
extern "C" {
    pub fn vips_call_argv(
        operation: *mut VipsOperation,
        argc: ::std::os::raw::c_int,
        argv: *mut *mut ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_cache_drop_all();
}
extern "C" {
    pub fn vips_cache_operation_lookup(operation: *mut VipsOperation) -> *mut VipsOperation;
}
extern "C" {
    pub fn vips_cache_operation_add(operation: *mut VipsOperation);
}
extern "C" {
    pub fn vips_cache_operation_buildp(operation: *mut *mut VipsOperation)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_cache_operation_build(operation: *mut VipsOperation) -> *mut VipsOperation;
}
extern "C" {
    pub fn vips_cache_print();
}
extern "C" {
    pub fn vips_cache_set_max(max: ::std::os::raw::c_int);
}
extern "C" {
    pub fn vips_cache_set_max_mem(max_mem: usize);
}
extern "C" {
    pub fn vips_cache_get_max() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_cache_get_size() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_cache_get_max_mem() -> usize;
}
extern "C" {
    pub fn vips_cache_get_max_files() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_cache_set_max_files(max_files: ::std::os::raw::c_int);
}
extern "C" {
    pub fn vips_cache_set_dump(dump: gboolean);
}
extern "C" {
    pub fn vips_cache_set_trace(trace: gboolean);
}
extern "C" {
    pub fn vips_concurrency_set(concurrency: ::std::os::raw::c_int);
}
extern "C" {
    pub fn vips_concurrency_get() -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsForeign {
    pub parent_object: VipsOperation,
}
#[test]
fn bindgen_test_layout__VipsForeign() {
    assert_eq!(
        ::std::mem::size_of::<_VipsForeign>(),
        96usize,
        concat!("Size of: ", stringify!(_VipsForeign))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsForeign>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsForeign))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeign>())).parent_object as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeign),
            "::",
            stringify!(parent_object)
        )
    );
}
pub type VipsForeign = _VipsForeign;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsForeignClass {
    pub parent_class: VipsOperationClass,
    pub priority: ::std::os::raw::c_int,
    pub suffs: *mut *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__VipsForeignClass() {
    assert_eq!(
        ::std::mem::size_of::<_VipsForeignClass>(),
        376usize,
        concat!("Size of: ", stringify!(_VipsForeignClass))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsForeignClass>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsForeignClass))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignClass>())).parent_class as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignClass),
            "::",
            stringify!(parent_class)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignClass>())).priority as *const _ as usize },
        360usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignClass),
            "::",
            stringify!(priority)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignClass>())).suffs as *const _ as usize },
        368usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignClass),
            "::",
            stringify!(suffs)
        )
    );
}
pub type VipsForeignClass = _VipsForeignClass;
extern "C" {
    pub fn vips_foreign_get_type() -> GType;
}
extern "C" {
    pub fn vips_foreign_map(
        base: *const ::std::os::raw::c_char,
        fn_: VipsSListMap2Fn,
        a: *mut ::std::os::raw::c_void,
        b: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void;
}
pub const VipsForeignFlags_VIPS_FOREIGN_NONE: VipsForeignFlags = 0;
pub const VipsForeignFlags_VIPS_FOREIGN_PARTIAL: VipsForeignFlags = 1;
pub const VipsForeignFlags_VIPS_FOREIGN_BIGENDIAN: VipsForeignFlags = 2;
pub const VipsForeignFlags_VIPS_FOREIGN_SEQUENTIAL: VipsForeignFlags = 4;
pub const VipsForeignFlags_VIPS_FOREIGN_ALL: VipsForeignFlags = 7;
pub type VipsForeignFlags = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsForeignLoad {
    pub parent_object: VipsForeign,
    pub memory: gboolean,
    pub access: VipsAccess,
    pub flags: VipsForeignFlags,
    pub fail: gboolean,
    pub sequential: gboolean,
    pub out: *mut VipsImage,
    pub real: *mut VipsImage,
    pub nocache: gboolean,
    pub disc: gboolean,
    pub error: gboolean,
}
#[test]
fn bindgen_test_layout__VipsForeignLoad() {
    assert_eq!(
        ::std::mem::size_of::<_VipsForeignLoad>(),
        152usize,
        concat!("Size of: ", stringify!(_VipsForeignLoad))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsForeignLoad>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsForeignLoad))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignLoad>())).parent_object as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignLoad),
            "::",
            stringify!(parent_object)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignLoad>())).memory as *const _ as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignLoad),
            "::",
            stringify!(memory)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignLoad>())).access as *const _ as usize },
        100usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignLoad),
            "::",
            stringify!(access)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignLoad>())).flags as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignLoad),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignLoad>())).fail as *const _ as usize },
        108usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignLoad),
            "::",
            stringify!(fail)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignLoad>())).sequential as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignLoad),
            "::",
            stringify!(sequential)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignLoad>())).out as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignLoad),
            "::",
            stringify!(out)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignLoad>())).real as *const _ as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignLoad),
            "::",
            stringify!(real)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignLoad>())).nocache as *const _ as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignLoad),
            "::",
            stringify!(nocache)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignLoad>())).disc as *const _ as usize },
        140usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignLoad),
            "::",
            stringify!(disc)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignLoad>())).error as *const _ as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignLoad),
            "::",
            stringify!(error)
        )
    );
}
pub type VipsForeignLoad = _VipsForeignLoad;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsForeignLoadClass {
    pub parent_class: VipsForeignClass,
    pub is_a: ::std::option::Option<
        unsafe extern "C" fn(filename: *const ::std::os::raw::c_char) -> gboolean,
    >,
    pub is_a_buffer: ::std::option::Option<
        unsafe extern "C" fn(data: *const ::std::os::raw::c_void, size: usize) -> gboolean,
    >,
    pub get_flags_filename: ::std::option::Option<
        unsafe extern "C" fn(filename: *const ::std::os::raw::c_char) -> VipsForeignFlags,
    >,
    pub get_flags:
        ::std::option::Option<unsafe extern "C" fn(load: *mut VipsForeignLoad) -> VipsForeignFlags>,
    pub header: ::std::option::Option<
        unsafe extern "C" fn(load: *mut VipsForeignLoad) -> ::std::os::raw::c_int,
    >,
    pub load: ::std::option::Option<
        unsafe extern "C" fn(load: *mut VipsForeignLoad) -> ::std::os::raw::c_int,
    >,
}
#[test]
fn bindgen_test_layout__VipsForeignLoadClass() {
    assert_eq!(
        ::std::mem::size_of::<_VipsForeignLoadClass>(),
        424usize,
        concat!("Size of: ", stringify!(_VipsForeignLoadClass))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsForeignLoadClass>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsForeignLoadClass))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsForeignLoadClass>())).parent_class as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignLoadClass),
            "::",
            stringify!(parent_class)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignLoadClass>())).is_a as *const _ as usize },
        376usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignLoadClass),
            "::",
            stringify!(is_a)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsForeignLoadClass>())).is_a_buffer as *const _ as usize
        },
        384usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignLoadClass),
            "::",
            stringify!(is_a_buffer)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsForeignLoadClass>())).get_flags_filename as *const _
                as usize
        },
        392usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignLoadClass),
            "::",
            stringify!(get_flags_filename)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignLoadClass>())).get_flags as *const _ as usize },
        400usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignLoadClass),
            "::",
            stringify!(get_flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignLoadClass>())).header as *const _ as usize },
        408usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignLoadClass),
            "::",
            stringify!(header)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignLoadClass>())).load as *const _ as usize },
        416usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignLoadClass),
            "::",
            stringify!(load)
        )
    );
}
pub type VipsForeignLoadClass = _VipsForeignLoadClass;
extern "C" {
    pub fn vips_foreign_load_get_type() -> GType;
}
extern "C" {
    pub fn vips_foreign_find_load(
        filename: *const ::std::os::raw::c_char,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_foreign_find_load_buffer(
        data: *const ::std::os::raw::c_void,
        size: usize,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_foreign_flags(
        loader: *const ::std::os::raw::c_char,
        filename: *const ::std::os::raw::c_char,
    ) -> VipsForeignFlags;
}
extern "C" {
    pub fn vips_foreign_is_a(
        loader: *const ::std::os::raw::c_char,
        filename: *const ::std::os::raw::c_char,
    ) -> gboolean;
}
extern "C" {
    pub fn vips_foreign_is_a_buffer(
        loader: *const ::std::os::raw::c_char,
        data: *const ::std::os::raw::c_void,
        size: usize,
    ) -> gboolean;
}
extern "C" {
    pub fn vips_foreign_load_invalidate(image: *mut VipsImage);
}
pub const VipsSaveable_VIPS_SAVEABLE_MONO: VipsSaveable = 0;
pub const VipsSaveable_VIPS_SAVEABLE_RGB: VipsSaveable = 1;
pub const VipsSaveable_VIPS_SAVEABLE_RGBA: VipsSaveable = 2;
pub const VipsSaveable_VIPS_SAVEABLE_RGBA_ONLY: VipsSaveable = 3;
pub const VipsSaveable_VIPS_SAVEABLE_RGB_CMYK: VipsSaveable = 4;
pub const VipsSaveable_VIPS_SAVEABLE_ANY: VipsSaveable = 5;
pub const VipsSaveable_VIPS_SAVEABLE_LAST: VipsSaveable = 6;
pub type VipsSaveable = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsForeignSave {
    pub parent_object: VipsForeign,
    pub strip: gboolean,
    pub background: *mut VipsArrayDouble,
    pub page_height: ::std::os::raw::c_int,
    pub in_: *mut VipsImage,
    pub ready: *mut VipsImage,
}
#[test]
fn bindgen_test_layout__VipsForeignSave() {
    assert_eq!(
        ::std::mem::size_of::<_VipsForeignSave>(),
        136usize,
        concat!("Size of: ", stringify!(_VipsForeignSave))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsForeignSave>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsForeignSave))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignSave>())).parent_object as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignSave),
            "::",
            stringify!(parent_object)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignSave>())).strip as *const _ as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignSave),
            "::",
            stringify!(strip)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignSave>())).background as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignSave),
            "::",
            stringify!(background)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignSave>())).page_height as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignSave),
            "::",
            stringify!(page_height)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignSave>())).in_ as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignSave),
            "::",
            stringify!(in_)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignSave>())).ready as *const _ as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignSave),
            "::",
            stringify!(ready)
        )
    );
}
pub type VipsForeignSave = _VipsForeignSave;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _VipsForeignSaveClass {
    pub parent_class: VipsForeignClass,
    pub saveable: VipsSaveable,
    pub format_table: *mut VipsBandFormat,
    pub coding: [gboolean; 7usize],
}
#[test]
fn bindgen_test_layout__VipsForeignSaveClass() {
    assert_eq!(
        ::std::mem::size_of::<_VipsForeignSaveClass>(),
        424usize,
        concat!("Size of: ", stringify!(_VipsForeignSaveClass))
    );
    assert_eq!(
        ::std::mem::align_of::<_VipsForeignSaveClass>(),
        8usize,
        concat!("Alignment of ", stringify!(_VipsForeignSaveClass))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsForeignSaveClass>())).parent_class as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignSaveClass),
            "::",
            stringify!(parent_class)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignSaveClass>())).saveable as *const _ as usize },
        376usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignSaveClass),
            "::",
            stringify!(saveable)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_VipsForeignSaveClass>())).format_table as *const _ as usize
        },
        384usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignSaveClass),
            "::",
            stringify!(format_table)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_VipsForeignSaveClass>())).coding as *const _ as usize },
        392usize,
        concat!(
            "Offset of field: ",
            stringify!(_VipsForeignSaveClass),
            "::",
            stringify!(coding)
        )
    );
}
pub type VipsForeignSaveClass = _VipsForeignSaveClass;
extern "C" {
    pub fn vips_foreign_save_get_type() -> GType;
}
extern "C" {
    pub fn vips_foreign_find_save(
        filename: *const ::std::os::raw::c_char,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_foreign_get_suffixes() -> *mut *mut gchar;
}
extern "C" {
    pub fn vips_foreign_find_save_buffer(
        suffix: *const ::std::os::raw::c_char,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_vipsload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_vipssave(
        in_: *mut VipsImage,
        filename: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_openslideload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_jpegload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_jpegload_buffer(
        buf: *mut ::std::os::raw::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_jpegsave(
        in_: *mut VipsImage,
        filename: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_jpegsave_buffer(
        in_: *mut VipsImage,
        buf: *mut *mut ::std::os::raw::c_void,
        len: *mut usize,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_jpegsave_mime(in_: *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
pub const VipsForeignWebpPreset_VIPS_FOREIGN_WEBP_PRESET_DEFAULT: VipsForeignWebpPreset = 0;
pub const VipsForeignWebpPreset_VIPS_FOREIGN_WEBP_PRESET_PICTURE: VipsForeignWebpPreset = 1;
pub const VipsForeignWebpPreset_VIPS_FOREIGN_WEBP_PRESET_PHOTO: VipsForeignWebpPreset = 2;
pub const VipsForeignWebpPreset_VIPS_FOREIGN_WEBP_PRESET_DRAWING: VipsForeignWebpPreset = 3;
pub const VipsForeignWebpPreset_VIPS_FOREIGN_WEBP_PRESET_ICON: VipsForeignWebpPreset = 4;
pub const VipsForeignWebpPreset_VIPS_FOREIGN_WEBP_PRESET_TEXT: VipsForeignWebpPreset = 5;
pub const VipsForeignWebpPreset_VIPS_FOREIGN_WEBP_PRESET_LAST: VipsForeignWebpPreset = 6;
pub type VipsForeignWebpPreset = u32;
extern "C" {
    pub fn vips_webpload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_webpload_buffer(
        buf: *mut ::std::os::raw::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_webpsave(
        in_: *mut VipsImage,
        filename: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_webpsave_buffer(
        in_: *mut VipsImage,
        buf: *mut *mut ::std::os::raw::c_void,
        len: *mut usize,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_webpsave_mime(in_: *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
pub const VipsForeignTiffCompression_VIPS_FOREIGN_TIFF_COMPRESSION_NONE:
    VipsForeignTiffCompression = 0;
pub const VipsForeignTiffCompression_VIPS_FOREIGN_TIFF_COMPRESSION_JPEG:
    VipsForeignTiffCompression = 1;
pub const VipsForeignTiffCompression_VIPS_FOREIGN_TIFF_COMPRESSION_DEFLATE:
    VipsForeignTiffCompression = 2;
pub const VipsForeignTiffCompression_VIPS_FOREIGN_TIFF_COMPRESSION_PACKBITS:
    VipsForeignTiffCompression = 3;
pub const VipsForeignTiffCompression_VIPS_FOREIGN_TIFF_COMPRESSION_CCITTFAX4:
    VipsForeignTiffCompression = 4;
pub const VipsForeignTiffCompression_VIPS_FOREIGN_TIFF_COMPRESSION_LZW: VipsForeignTiffCompression =
    5;
pub const VipsForeignTiffCompression_VIPS_FOREIGN_TIFF_COMPRESSION_LAST:
    VipsForeignTiffCompression = 6;
pub type VipsForeignTiffCompression = u32;
pub const VipsForeignTiffPredictor_VIPS_FOREIGN_TIFF_PREDICTOR_NONE: VipsForeignTiffPredictor = 1;
pub const VipsForeignTiffPredictor_VIPS_FOREIGN_TIFF_PREDICTOR_HORIZONTAL:
    VipsForeignTiffPredictor = 2;
pub const VipsForeignTiffPredictor_VIPS_FOREIGN_TIFF_PREDICTOR_FLOAT: VipsForeignTiffPredictor = 3;
pub const VipsForeignTiffPredictor_VIPS_FOREIGN_TIFF_PREDICTOR_LAST: VipsForeignTiffPredictor = 4;
pub type VipsForeignTiffPredictor = u32;
pub const VipsForeignTiffResunit_VIPS_FOREIGN_TIFF_RESUNIT_CM: VipsForeignTiffResunit = 0;
pub const VipsForeignTiffResunit_VIPS_FOREIGN_TIFF_RESUNIT_INCH: VipsForeignTiffResunit = 1;
pub const VipsForeignTiffResunit_VIPS_FOREIGN_TIFF_RESUNIT_LAST: VipsForeignTiffResunit = 2;
pub type VipsForeignTiffResunit = u32;
extern "C" {
    pub fn vips_tiffload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_tiffload_buffer(
        buf: *mut ::std::os::raw::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_tiffsave(
        in_: *mut VipsImage,
        filename: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_tiffsave_buffer(
        in_: *mut VipsImage,
        buf: *mut *mut ::std::os::raw::c_void,
        len: *mut usize,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_openexrload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_fitsload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_fitssave(
        in_: *mut VipsImage,
        filename: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_analyzeload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_rawload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        bands: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_rawsave(
        in_: *mut VipsImage,
        filename: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_rawsave_fd(
        in_: *mut VipsImage,
        fd: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_csvload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_csvsave(
        in_: *mut VipsImage,
        filename: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_matrixload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_matrixsave(
        in_: *mut VipsImage,
        filename: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_matrixprint(in_: *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_magickload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_magickload_buffer(
        buf: *mut ::std::os::raw::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_magicksave(
        in_: *mut VipsImage,
        filename: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_magicksave_buffer(
        in_: *mut VipsImage,
        buf: *mut *mut ::std::os::raw::c_void,
        len: *mut usize,
        ...
    ) -> ::std::os::raw::c_int;
}
pub const VipsForeignPngFilter_VIPS_FOREIGN_PNG_FILTER_NONE: VipsForeignPngFilter = 8;
pub const VipsForeignPngFilter_VIPS_FOREIGN_PNG_FILTER_SUB: VipsForeignPngFilter = 16;
pub const VipsForeignPngFilter_VIPS_FOREIGN_PNG_FILTER_UP: VipsForeignPngFilter = 32;
pub const VipsForeignPngFilter_VIPS_FOREIGN_PNG_FILTER_AVG: VipsForeignPngFilter = 64;
pub const VipsForeignPngFilter_VIPS_FOREIGN_PNG_FILTER_PAETH: VipsForeignPngFilter = 128;
pub const VipsForeignPngFilter_VIPS_FOREIGN_PNG_FILTER_ALL: VipsForeignPngFilter = 248;
pub type VipsForeignPngFilter = u32;
extern "C" {
    pub fn vips_pngload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_pngload_buffer(
        buf: *mut ::std::os::raw::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_pngsave(
        in_: *mut VipsImage,
        filename: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_pngsave_buffer(
        in_: *mut VipsImage,
        buf: *mut *mut ::std::os::raw::c_void,
        len: *mut usize,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_ppmload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_ppmsave(
        in_: *mut VipsImage,
        filename: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_matload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_radload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_radsave(
        in_: *mut VipsImage,
        filename: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_radsave_buffer(
        in_: *mut VipsImage,
        buf: *mut *mut ::std::os::raw::c_void,
        len: *mut usize,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_pdfload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_pdfload_buffer(
        buf: *mut ::std::os::raw::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_svgload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_svgload_buffer(
        buf: *mut ::std::os::raw::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_gifload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_gifload_buffer(
        buf: *mut ::std::os::raw::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_heifload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_heifload_buffer(
        buf: *mut ::std::os::raw::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_heifsave(
        in_: *mut VipsImage,
        filename: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_heifsave_buffer(
        in_: *mut VipsImage,
        buf: *mut *mut ::std::os::raw::c_void,
        len: *mut usize,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_niftiload(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_niftisave(
        in_: *mut VipsImage,
        filename: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
pub const VipsForeignDzLayout_VIPS_FOREIGN_DZ_LAYOUT_DZ: VipsForeignDzLayout = 0;
pub const VipsForeignDzLayout_VIPS_FOREIGN_DZ_LAYOUT_ZOOMIFY: VipsForeignDzLayout = 1;
pub const VipsForeignDzLayout_VIPS_FOREIGN_DZ_LAYOUT_GOOGLE: VipsForeignDzLayout = 2;
pub const VipsForeignDzLayout_VIPS_FOREIGN_DZ_LAYOUT_LAST: VipsForeignDzLayout = 3;
pub type VipsForeignDzLayout = u32;
pub const VipsForeignDzDepth_VIPS_FOREIGN_DZ_DEPTH_ONEPIXEL: VipsForeignDzDepth = 0;
pub const VipsForeignDzDepth_VIPS_FOREIGN_DZ_DEPTH_ONETILE: VipsForeignDzDepth = 1;
pub const VipsForeignDzDepth_VIPS_FOREIGN_DZ_DEPTH_ONE: VipsForeignDzDepth = 2;
pub const VipsForeignDzDepth_VIPS_FOREIGN_DZ_DEPTH_LAST: VipsForeignDzDepth = 3;
pub type VipsForeignDzDepth = u32;
pub const VipsForeignDzContainer_VIPS_FOREIGN_DZ_CONTAINER_FS: VipsForeignDzContainer = 0;
pub const VipsForeignDzContainer_VIPS_FOREIGN_DZ_CONTAINER_ZIP: VipsForeignDzContainer = 1;
pub const VipsForeignDzContainer_VIPS_FOREIGN_DZ_CONTAINER_SZI: VipsForeignDzContainer = 2;
pub const VipsForeignDzContainer_VIPS_FOREIGN_DZ_CONTAINER_LAST: VipsForeignDzContainer = 3;
pub type VipsForeignDzContainer = u32;
extern "C" {
    pub fn vips_dzsave(
        in_: *mut VipsImage,
        name: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_operation_math_get_type() -> GType;
}
extern "C" {
    pub fn vips_operation_math2_get_type() -> GType;
}
extern "C" {
    pub fn vips_operation_round_get_type() -> GType;
}
extern "C" {
    pub fn vips_operation_relational_get_type() -> GType;
}
extern "C" {
    pub fn vips_operation_boolean_get_type() -> GType;
}
extern "C" {
    pub fn vips_operation_complex_get_type() -> GType;
}
extern "C" {
    pub fn vips_operation_complex2_get_type() -> GType;
}
extern "C" {
    pub fn vips_operation_complexget_get_type() -> GType;
}
extern "C" {
    pub fn vips_precision_get_type() -> GType;
}
extern "C" {
    pub fn vips_intent_get_type() -> GType;
}
extern "C" {
    pub fn vips_pcs_get_type() -> GType;
}
extern "C" {
    pub fn vips_extend_get_type() -> GType;
}
extern "C" {
    pub fn vips_compass_direction_get_type() -> GType;
}
extern "C" {
    pub fn vips_direction_get_type() -> GType;
}
extern "C" {
    pub fn vips_align_get_type() -> GType;
}
extern "C" {
    pub fn vips_angle_get_type() -> GType;
}
extern "C" {
    pub fn vips_angle45_get_type() -> GType;
}
extern "C" {
    pub fn vips_interesting_get_type() -> GType;
}
extern "C" {
    pub fn vips_blend_mode_get_type() -> GType;
}
extern "C" {
    pub fn vips_combine_get_type() -> GType;
}
extern "C" {
    pub fn vips_combine_mode_get_type() -> GType;
}
extern "C" {
    pub fn vips_foreign_flags_get_type() -> GType;
}
extern "C" {
    pub fn vips_saveable_get_type() -> GType;
}
extern "C" {
    pub fn vips_foreign_webp_preset_get_type() -> GType;
}
extern "C" {
    pub fn vips_foreign_tiff_compression_get_type() -> GType;
}
extern "C" {
    pub fn vips_foreign_tiff_predictor_get_type() -> GType;
}
extern "C" {
    pub fn vips_foreign_tiff_resunit_get_type() -> GType;
}
extern "C" {
    pub fn vips_foreign_png_filter_get_type() -> GType;
}
extern "C" {
    pub fn vips_foreign_dz_layout_get_type() -> GType;
}
extern "C" {
    pub fn vips_foreign_dz_depth_get_type() -> GType;
}
extern "C" {
    pub fn vips_foreign_dz_container_get_type() -> GType;
}
extern "C" {
    pub fn vips_demand_style_get_type() -> GType;
}
extern "C" {
    pub fn vips_image_type_get_type() -> GType;
}
extern "C" {
    pub fn vips_interpretation_get_type() -> GType;
}
extern "C" {
    pub fn vips_band_format_get_type() -> GType;
}
extern "C" {
    pub fn vips_coding_get_type() -> GType;
}
extern "C" {
    pub fn vips_access_get_type() -> GType;
}
extern "C" {
    pub fn vips_operation_morphology_get_type() -> GType;
}
extern "C" {
    pub fn vips_argument_flags_get_type() -> GType;
}
extern "C" {
    pub fn vips_operation_flags_get_type() -> GType;
}
extern "C" {
    pub fn vips_region_shrink_get_type() -> GType;
}
extern "C" {
    pub fn vips_kernel_get_type() -> GType;
}
extern "C" {
    pub fn vips_size_get_type() -> GType;
}
extern "C" {
    pub fn vips_token_get_type() -> GType;
}
pub const VipsOperationMath_VIPS_OPERATION_MATH_SIN: VipsOperationMath = 0;
pub const VipsOperationMath_VIPS_OPERATION_MATH_COS: VipsOperationMath = 1;
pub const VipsOperationMath_VIPS_OPERATION_MATH_TAN: VipsOperationMath = 2;
pub const VipsOperationMath_VIPS_OPERATION_MATH_ASIN: VipsOperationMath = 3;
pub const VipsOperationMath_VIPS_OPERATION_MATH_ACOS: VipsOperationMath = 4;
pub const VipsOperationMath_VIPS_OPERATION_MATH_ATAN: VipsOperationMath = 5;
pub const VipsOperationMath_VIPS_OPERATION_MATH_LOG: VipsOperationMath = 6;
pub const VipsOperationMath_VIPS_OPERATION_MATH_LOG10: VipsOperationMath = 7;
pub const VipsOperationMath_VIPS_OPERATION_MATH_EXP: VipsOperationMath = 8;
pub const VipsOperationMath_VIPS_OPERATION_MATH_EXP10: VipsOperationMath = 9;
pub const VipsOperationMath_VIPS_OPERATION_MATH_LAST: VipsOperationMath = 10;
pub type VipsOperationMath = u32;
pub const VipsOperationMath2_VIPS_OPERATION_MATH2_POW: VipsOperationMath2 = 0;
pub const VipsOperationMath2_VIPS_OPERATION_MATH2_WOP: VipsOperationMath2 = 1;
pub const VipsOperationMath2_VIPS_OPERATION_MATH2_LAST: VipsOperationMath2 = 2;
pub type VipsOperationMath2 = u32;
pub const VipsOperationRound_VIPS_OPERATION_ROUND_RINT: VipsOperationRound = 0;
pub const VipsOperationRound_VIPS_OPERATION_ROUND_CEIL: VipsOperationRound = 1;
pub const VipsOperationRound_VIPS_OPERATION_ROUND_FLOOR: VipsOperationRound = 2;
pub const VipsOperationRound_VIPS_OPERATION_ROUND_LAST: VipsOperationRound = 3;
pub type VipsOperationRound = u32;
pub const VipsOperationRelational_VIPS_OPERATION_RELATIONAL_EQUAL: VipsOperationRelational = 0;
pub const VipsOperationRelational_VIPS_OPERATION_RELATIONAL_NOTEQ: VipsOperationRelational = 1;
pub const VipsOperationRelational_VIPS_OPERATION_RELATIONAL_LESS: VipsOperationRelational = 2;
pub const VipsOperationRelational_VIPS_OPERATION_RELATIONAL_LESSEQ: VipsOperationRelational = 3;
pub const VipsOperationRelational_VIPS_OPERATION_RELATIONAL_MORE: VipsOperationRelational = 4;
pub const VipsOperationRelational_VIPS_OPERATION_RELATIONAL_MOREEQ: VipsOperationRelational = 5;
pub const VipsOperationRelational_VIPS_OPERATION_RELATIONAL_LAST: VipsOperationRelational = 6;
pub type VipsOperationRelational = u32;
pub const VipsOperationBoolean_VIPS_OPERATION_BOOLEAN_AND: VipsOperationBoolean = 0;
pub const VipsOperationBoolean_VIPS_OPERATION_BOOLEAN_OR: VipsOperationBoolean = 1;
pub const VipsOperationBoolean_VIPS_OPERATION_BOOLEAN_EOR: VipsOperationBoolean = 2;
pub const VipsOperationBoolean_VIPS_OPERATION_BOOLEAN_LSHIFT: VipsOperationBoolean = 3;
pub const VipsOperationBoolean_VIPS_OPERATION_BOOLEAN_RSHIFT: VipsOperationBoolean = 4;
pub const VipsOperationBoolean_VIPS_OPERATION_BOOLEAN_LAST: VipsOperationBoolean = 5;
pub type VipsOperationBoolean = u32;
pub const VipsOperationComplex_VIPS_OPERATION_COMPLEX_POLAR: VipsOperationComplex = 0;
pub const VipsOperationComplex_VIPS_OPERATION_COMPLEX_RECT: VipsOperationComplex = 1;
pub const VipsOperationComplex_VIPS_OPERATION_COMPLEX_CONJ: VipsOperationComplex = 2;
pub const VipsOperationComplex_VIPS_OPERATION_COMPLEX_LAST: VipsOperationComplex = 3;
pub type VipsOperationComplex = u32;
pub const VipsOperationComplex2_VIPS_OPERATION_COMPLEX2_CROSS_PHASE: VipsOperationComplex2 = 0;
pub const VipsOperationComplex2_VIPS_OPERATION_COMPLEX2_LAST: VipsOperationComplex2 = 1;
pub type VipsOperationComplex2 = u32;
pub const VipsOperationComplexget_VIPS_OPERATION_COMPLEXGET_REAL: VipsOperationComplexget = 0;
pub const VipsOperationComplexget_VIPS_OPERATION_COMPLEXGET_IMAG: VipsOperationComplexget = 1;
pub const VipsOperationComplexget_VIPS_OPERATION_COMPLEXGET_LAST: VipsOperationComplexget = 2;
pub type VipsOperationComplexget = u32;
extern "C" {
    pub fn vips_add(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_sum(
        in_: *mut *mut VipsImage,
        out: *mut *mut VipsImage,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_subtract(
        in1: *mut VipsImage,
        in2: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_multiply(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_divide(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_linear(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        a: *mut f64,
        b: *mut f64,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_linear1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        a: f64,
        b: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_remainder(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_remainder_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *mut f64,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_remainder_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_invert(in_: *mut VipsImage, out: *mut *mut VipsImage, ...)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_abs(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_sign(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_round(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        round: VipsOperationRound,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_floor(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_ceil(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_rint(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_math(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        math: VipsOperationMath,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_sin(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_cos(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_tan(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_asin(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_acos(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_atan(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_exp(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_exp10(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_log(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_log10(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_complex(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        cmplx: VipsOperationComplex,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_polar(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_rect(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_conj(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_complex2(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        cmplx: VipsOperationComplex2,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_cross_phase(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_complexget(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        get: VipsOperationComplexget,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_real(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_imag(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_complexform(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_relational(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        relational: VipsOperationRelational,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_equal(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_notequal(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_less(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_lesseq(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_more(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_moreeq(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_relational_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        relational: VipsOperationRelational,
        c: *mut f64,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_equal_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *mut f64,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_notequal_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *mut f64,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_less_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *mut f64,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_lesseq_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *mut f64,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_more_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *mut f64,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_moreeq_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *mut f64,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_relational_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        relational: VipsOperationRelational,
        c: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_equal_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_notequal_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_less_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_lesseq_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_more_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_moreeq_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_boolean(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        boolean: VipsOperationBoolean,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_andimage(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_orimage(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_eorimage(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_lshift(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_rshift(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_boolean_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        boolean: VipsOperationBoolean,
        c: *mut f64,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_andimage_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *mut f64,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_orimage_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *mut f64,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_eorimage_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *mut f64,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_lshift_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *mut f64,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_rshift_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *mut f64,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_boolean_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        boolean: VipsOperationBoolean,
        c: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_andimage_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_orimage_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_eorimage_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_lshift_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_rshift_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_math2(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        math2: VipsOperationMath2,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_pow(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_wop(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_math2_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        math2: VipsOperationMath2,
        c: *mut f64,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_pow_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *mut f64,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_wop_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *mut f64,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_math2_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        math2: VipsOperationMath2,
        c: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_pow_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_wop_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_avg(in_: *mut VipsImage, out: *mut f64, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_deviate(in_: *mut VipsImage, out: *mut f64, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_min(in_: *mut VipsImage, out: *mut f64, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_max(in_: *mut VipsImage, out: *mut f64, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_stats(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_measure(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        h: ::std::os::raw::c_int,
        v: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_find_trim(
        in_: *mut VipsImage,
        left: *mut ::std::os::raw::c_int,
        top: *mut ::std::os::raw::c_int,
        width: *mut ::std::os::raw::c_int,
        height: *mut ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_getpoint(
        in_: *mut VipsImage,
        vector: *mut *mut f64,
        n: *mut ::std::os::raw::c_int,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_hist_find(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_hist_find_ndim(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_hist_find_indexed(
        in_: *mut VipsImage,
        index: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_hough_line(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_hough_circle(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_project(
        in_: *mut VipsImage,
        columns: *mut *mut VipsImage,
        rows: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_profile(
        in_: *mut VipsImage,
        columns: *mut *mut VipsImage,
        rows: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
pub const VipsExtend_VIPS_EXTEND_BLACK: VipsExtend = 0;
pub const VipsExtend_VIPS_EXTEND_COPY: VipsExtend = 1;
pub const VipsExtend_VIPS_EXTEND_REPEAT: VipsExtend = 2;
pub const VipsExtend_VIPS_EXTEND_MIRROR: VipsExtend = 3;
pub const VipsExtend_VIPS_EXTEND_WHITE: VipsExtend = 4;
pub const VipsExtend_VIPS_EXTEND_BACKGROUND: VipsExtend = 5;
pub const VipsExtend_VIPS_EXTEND_LAST: VipsExtend = 6;
pub type VipsExtend = u32;
pub const VipsCompassDirection_VIPS_COMPASS_DIRECTION_CENTRE: VipsCompassDirection = 0;
pub const VipsCompassDirection_VIPS_COMPASS_DIRECTION_NORTH: VipsCompassDirection = 1;
pub const VipsCompassDirection_VIPS_COMPASS_DIRECTION_EAST: VipsCompassDirection = 2;
pub const VipsCompassDirection_VIPS_COMPASS_DIRECTION_SOUTH: VipsCompassDirection = 3;
pub const VipsCompassDirection_VIPS_COMPASS_DIRECTION_WEST: VipsCompassDirection = 4;
pub const VipsCompassDirection_VIPS_COMPASS_DIRECTION_NORTH_EAST: VipsCompassDirection = 5;
pub const VipsCompassDirection_VIPS_COMPASS_DIRECTION_SOUTH_EAST: VipsCompassDirection = 6;
pub const VipsCompassDirection_VIPS_COMPASS_DIRECTION_SOUTH_WEST: VipsCompassDirection = 7;
pub const VipsCompassDirection_VIPS_COMPASS_DIRECTION_NORTH_WEST: VipsCompassDirection = 8;
pub const VipsCompassDirection_VIPS_COMPASS_DIRECTION_LAST: VipsCompassDirection = 9;
pub type VipsCompassDirection = u32;
pub const VipsDirection_VIPS_DIRECTION_HORIZONTAL: VipsDirection = 0;
pub const VipsDirection_VIPS_DIRECTION_VERTICAL: VipsDirection = 1;
pub const VipsDirection_VIPS_DIRECTION_LAST: VipsDirection = 2;
pub type VipsDirection = u32;
pub const VipsAlign_VIPS_ALIGN_LOW: VipsAlign = 0;
pub const VipsAlign_VIPS_ALIGN_CENTRE: VipsAlign = 1;
pub const VipsAlign_VIPS_ALIGN_HIGH: VipsAlign = 2;
pub const VipsAlign_VIPS_ALIGN_LAST: VipsAlign = 3;
pub type VipsAlign = u32;
pub const VipsAngle_VIPS_ANGLE_D0: VipsAngle = 0;
pub const VipsAngle_VIPS_ANGLE_D90: VipsAngle = 1;
pub const VipsAngle_VIPS_ANGLE_D180: VipsAngle = 2;
pub const VipsAngle_VIPS_ANGLE_D270: VipsAngle = 3;
pub const VipsAngle_VIPS_ANGLE_LAST: VipsAngle = 4;
pub type VipsAngle = u32;
pub const VipsAngle45_VIPS_ANGLE45_D0: VipsAngle45 = 0;
pub const VipsAngle45_VIPS_ANGLE45_D45: VipsAngle45 = 1;
pub const VipsAngle45_VIPS_ANGLE45_D90: VipsAngle45 = 2;
pub const VipsAngle45_VIPS_ANGLE45_D135: VipsAngle45 = 3;
pub const VipsAngle45_VIPS_ANGLE45_D180: VipsAngle45 = 4;
pub const VipsAngle45_VIPS_ANGLE45_D225: VipsAngle45 = 5;
pub const VipsAngle45_VIPS_ANGLE45_D270: VipsAngle45 = 6;
pub const VipsAngle45_VIPS_ANGLE45_D315: VipsAngle45 = 7;
pub const VipsAngle45_VIPS_ANGLE45_LAST: VipsAngle45 = 8;
pub type VipsAngle45 = u32;
pub const VipsInteresting_VIPS_INTERESTING_NONE: VipsInteresting = 0;
pub const VipsInteresting_VIPS_INTERESTING_CENTRE: VipsInteresting = 1;
pub const VipsInteresting_VIPS_INTERESTING_ENTROPY: VipsInteresting = 2;
pub const VipsInteresting_VIPS_INTERESTING_ATTENTION: VipsInteresting = 3;
pub const VipsInteresting_VIPS_INTERESTING_LOW: VipsInteresting = 4;
pub const VipsInteresting_VIPS_INTERESTING_HIGH: VipsInteresting = 5;
pub const VipsInteresting_VIPS_INTERESTING_LAST: VipsInteresting = 6;
pub type VipsInteresting = u32;
pub const VipsBlendMode_VIPS_BLEND_MODE_CLEAR: VipsBlendMode = 0;
pub const VipsBlendMode_VIPS_BLEND_MODE_SOURCE: VipsBlendMode = 1;
pub const VipsBlendMode_VIPS_BLEND_MODE_OVER: VipsBlendMode = 2;
pub const VipsBlendMode_VIPS_BLEND_MODE_IN: VipsBlendMode = 3;
pub const VipsBlendMode_VIPS_BLEND_MODE_OUT: VipsBlendMode = 4;
pub const VipsBlendMode_VIPS_BLEND_MODE_ATOP: VipsBlendMode = 5;
pub const VipsBlendMode_VIPS_BLEND_MODE_DEST: VipsBlendMode = 6;
pub const VipsBlendMode_VIPS_BLEND_MODE_DEST_OVER: VipsBlendMode = 7;
pub const VipsBlendMode_VIPS_BLEND_MODE_DEST_IN: VipsBlendMode = 8;
pub const VipsBlendMode_VIPS_BLEND_MODE_DEST_OUT: VipsBlendMode = 9;
pub const VipsBlendMode_VIPS_BLEND_MODE_DEST_ATOP: VipsBlendMode = 10;
pub const VipsBlendMode_VIPS_BLEND_MODE_XOR: VipsBlendMode = 11;
pub const VipsBlendMode_VIPS_BLEND_MODE_ADD: VipsBlendMode = 12;
pub const VipsBlendMode_VIPS_BLEND_MODE_SATURATE: VipsBlendMode = 13;
pub const VipsBlendMode_VIPS_BLEND_MODE_MULTIPLY: VipsBlendMode = 14;
pub const VipsBlendMode_VIPS_BLEND_MODE_SCREEN: VipsBlendMode = 15;
pub const VipsBlendMode_VIPS_BLEND_MODE_OVERLAY: VipsBlendMode = 16;
pub const VipsBlendMode_VIPS_BLEND_MODE_DARKEN: VipsBlendMode = 17;
pub const VipsBlendMode_VIPS_BLEND_MODE_LIGHTEN: VipsBlendMode = 18;
pub const VipsBlendMode_VIPS_BLEND_MODE_COLOUR_DODGE: VipsBlendMode = 19;
pub const VipsBlendMode_VIPS_BLEND_MODE_COLOUR_BURN: VipsBlendMode = 20;
pub const VipsBlendMode_VIPS_BLEND_MODE_HARD_LIGHT: VipsBlendMode = 21;
pub const VipsBlendMode_VIPS_BLEND_MODE_SOFT_LIGHT: VipsBlendMode = 22;
pub const VipsBlendMode_VIPS_BLEND_MODE_DIFFERENCE: VipsBlendMode = 23;
pub const VipsBlendMode_VIPS_BLEND_MODE_EXCLUSION: VipsBlendMode = 24;
pub const VipsBlendMode_VIPS_BLEND_MODE_LAST: VipsBlendMode = 25;
pub type VipsBlendMode = u32;
extern "C" {
    pub fn vips_copy(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_tilecache(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_linecache(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_sequential(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_cache(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_copy_file(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_embed(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_gravity(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        direction: VipsCompassDirection,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_flip(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        direction: VipsDirection,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_insert(
        main: *mut VipsImage,
        sub: *mut VipsImage,
        out: *mut *mut VipsImage,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_join(
        in1: *mut VipsImage,
        in2: *mut VipsImage,
        out: *mut *mut VipsImage,
        direction: VipsDirection,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_arrayjoin(
        in_: *mut *mut VipsImage,
        out: *mut *mut VipsImage,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_extract_area(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        left: ::std::os::raw::c_int,
        top: ::std::os::raw::c_int,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_crop(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        left: ::std::os::raw::c_int,
        top: ::std::os::raw::c_int,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_smartcrop(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_extract_band(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        band: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_replicate(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        across: ::std::os::raw::c_int,
        down: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_grid(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        tile_height: ::std::os::raw::c_int,
        across: ::std::os::raw::c_int,
        down: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_transpose3d(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_wrap(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_rot(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        angle: VipsAngle,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_rot90(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_rot180(in_: *mut VipsImage, out: *mut *mut VipsImage, ...)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_rot270(in_: *mut VipsImage, out: *mut *mut VipsImage, ...)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_rot45(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_autorot_get_angle(image: *mut VipsImage) -> VipsAngle;
}
extern "C" {
    pub fn vips_autorot_remove_angle(image: *mut VipsImage);
}
extern "C" {
    pub fn vips_autorot(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_zoom(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        xfac: ::std::os::raw::c_int,
        yfac: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_subsample(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        xfac: ::std::os::raw::c_int,
        yfac: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_cast(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        format: VipsBandFormat,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_cast_uchar(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_cast_char(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_cast_ushort(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_cast_short(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_cast_uint(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_cast_int(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_cast_float(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_cast_double(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_cast_complex(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_cast_dpcomplex(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_scale(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_msb(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_byteswap(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_bandjoin(
        in_: *mut *mut VipsImage,
        out: *mut *mut VipsImage,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_bandjoin2(
        in1: *mut VipsImage,
        in2: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_bandjoin_const(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: *mut f64,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_bandjoin_const1(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        c: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_bandrank(
        in_: *mut *mut VipsImage,
        out: *mut *mut VipsImage,
        n: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_bandfold(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_bandunfold(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_bandbool(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        boolean: VipsOperationBoolean,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_bandand(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_bandor(in_: *mut VipsImage, out: *mut *mut VipsImage, ...)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_bandeor(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_bandmean(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_recomb(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        m: *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_ifthenelse(
        cond: *mut VipsImage,
        in1: *mut VipsImage,
        in2: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_flatten(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_addalpha(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_premultiply(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_unpremultiply(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_composite(
        in_: *mut *mut VipsImage,
        out: *mut *mut VipsImage,
        n: ::std::os::raw::c_int,
        mode: *mut ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_composite2(
        base: *mut VipsImage,
        overlay: *mut VipsImage,
        out: *mut *mut VipsImage,
        mode1: VipsBlendMode,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_falsecolour(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_gamma(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
pub const VipsCombine_VIPS_COMBINE_MAX: VipsCombine = 0;
pub const VipsCombine_VIPS_COMBINE_SUM: VipsCombine = 1;
pub const VipsCombine_VIPS_COMBINE_MIN: VipsCombine = 2;
pub const VipsCombine_VIPS_COMBINE_LAST: VipsCombine = 3;
pub type VipsCombine = u32;
extern "C" {
    pub fn vips_conv(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        mask: *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_convf(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        mask: *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_convi(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        mask: *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_conva(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        mask: *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_convsep(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        mask: *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_convasep(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        mask: *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_compass(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        mask: *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_gaussblur(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        sigma: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_sharpen(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_spcor(
        in_: *mut VipsImage,
        ref_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_fastcor(
        in_: *mut VipsImage,
        ref_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_sobel(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_canny(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
pub const VipsOperationMorphology_VIPS_OPERATION_MORPHOLOGY_ERODE: VipsOperationMorphology = 0;
pub const VipsOperationMorphology_VIPS_OPERATION_MORPHOLOGY_DILATE: VipsOperationMorphology = 1;
pub const VipsOperationMorphology_VIPS_OPERATION_MORPHOLOGY_LAST: VipsOperationMorphology = 2;
pub type VipsOperationMorphology = u32;
extern "C" {
    pub fn vips_morph(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        mask: *mut VipsImage,
        morph: VipsOperationMorphology,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_rank(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        index: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_median(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        size: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_countlines(
        in_: *mut VipsImage,
        nolines: *mut f64,
        direction: VipsDirection,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_labelregions(
        in_: *mut VipsImage,
        mask: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_fill_nearest(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_merge(
        ref_: *mut VipsImage,
        sec: *mut VipsImage,
        out: *mut *mut VipsImage,
        direction: VipsDirection,
        dx: ::std::os::raw::c_int,
        dy: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_mosaic(
        ref_: *mut VipsImage,
        sec: *mut VipsImage,
        out: *mut *mut VipsImage,
        direction: VipsDirection,
        xref: ::std::os::raw::c_int,
        yref: ::std::os::raw::c_int,
        xsec: ::std::os::raw::c_int,
        ysec: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_mosaic1(
        ref_: *mut VipsImage,
        sec: *mut VipsImage,
        out: *mut *mut VipsImage,
        direction: VipsDirection,
        xr1: ::std::os::raw::c_int,
        yr1: ::std::os::raw::c_int,
        xs1: ::std::os::raw::c_int,
        ys1: ::std::os::raw::c_int,
        xr2: ::std::os::raw::c_int,
        yr2: ::std::os::raw::c_int,
        xs2: ::std::os::raw::c_int,
        ys2: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_match(
        ref_: *mut VipsImage,
        sec: *mut VipsImage,
        out: *mut *mut VipsImage,
        xr1: ::std::os::raw::c_int,
        yr1: ::std::os::raw::c_int,
        xs1: ::std::os::raw::c_int,
        ys1: ::std::os::raw::c_int,
        xr2: ::std::os::raw::c_int,
        yr2: ::std::os::raw::c_int,
        xs2: ::std::os::raw::c_int,
        ys2: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_globalbalance(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_remosaic(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        old_str: *const ::std::os::raw::c_char,
        new_str: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_maplut(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        lut: *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_percent(
        in_: *mut VipsImage,
        percent: f64,
        threshold: *mut ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_stdif(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_hist_cum(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_hist_norm(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_hist_equal(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_hist_plot(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_hist_match(
        in_: *mut VipsImage,
        ref_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_hist_local(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_hist_ismonotonic(
        in_: *mut VipsImage,
        out: *mut gboolean,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_hist_entropy(in_: *mut VipsImage, out: *mut f64, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_fwfft(in_: *mut VipsImage, out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_invfft(in_: *mut VipsImage, out: *mut *mut VipsImage, ...)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_freqmult(
        in_: *mut VipsImage,
        mask: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_spectrum(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_phasecor(
        in1: *mut VipsImage,
        in2: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
pub const VipsKernel_VIPS_KERNEL_NEAREST: VipsKernel = 0;
pub const VipsKernel_VIPS_KERNEL_LINEAR: VipsKernel = 1;
pub const VipsKernel_VIPS_KERNEL_CUBIC: VipsKernel = 2;
pub const VipsKernel_VIPS_KERNEL_MITCHELL: VipsKernel = 3;
pub const VipsKernel_VIPS_KERNEL_LANCZOS2: VipsKernel = 4;
pub const VipsKernel_VIPS_KERNEL_LANCZOS3: VipsKernel = 5;
pub const VipsKernel_VIPS_KERNEL_LAST: VipsKernel = 6;
pub type VipsKernel = u32;
pub const VipsSize_VIPS_SIZE_BOTH: VipsSize = 0;
pub const VipsSize_VIPS_SIZE_UP: VipsSize = 1;
pub const VipsSize_VIPS_SIZE_DOWN: VipsSize = 2;
pub const VipsSize_VIPS_SIZE_FORCE: VipsSize = 3;
pub const VipsSize_VIPS_SIZE_LAST: VipsSize = 4;
pub type VipsSize = u32;
extern "C" {
    pub fn vips_shrink(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        hshrink: f64,
        vshrink: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_shrinkh(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        hshrink: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_shrinkv(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        vshrink: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_reduce(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        hshrink: f64,
        vshrink: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_reduceh(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        hshrink: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_reducev(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        vshrink: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_thumbnail(
        filename: *const ::std::os::raw::c_char,
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_thumbnail_buffer(
        buf: *mut ::std::os::raw::c_void,
        len: usize,
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_thumbnail_image(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_similarity(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_rotate(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        angle: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_affine(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        a: f64,
        b: f64,
        c: f64,
        d: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_resize(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        scale: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_mapim(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        index: *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_quadratic(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        coeff: *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
pub const VipsIntent_VIPS_INTENT_PERCEPTUAL: VipsIntent = 0;
pub const VipsIntent_VIPS_INTENT_RELATIVE: VipsIntent = 1;
pub const VipsIntent_VIPS_INTENT_SATURATION: VipsIntent = 2;
pub const VipsIntent_VIPS_INTENT_ABSOLUTE: VipsIntent = 3;
pub const VipsIntent_VIPS_INTENT_LAST: VipsIntent = 4;
pub type VipsIntent = u32;
pub const VipsPCS_VIPS_PCS_LAB: VipsPCS = 0;
pub const VipsPCS_VIPS_PCS_XYZ: VipsPCS = 1;
pub const VipsPCS_VIPS_PCS_LAST: VipsPCS = 2;
pub type VipsPCS = u32;
extern "C" {
    pub fn vips_colourspace_issupported(image: *const VipsImage) -> gboolean;
}
extern "C" {
    pub fn vips_colourspace(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        space: VipsInterpretation,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_LabQ2sRGB(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_rad2float(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_float2rad(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_LabS2LabQ(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_LabQ2LabS(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_LabQ2Lab(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_Lab2LabQ(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_LCh2Lab(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_Lab2LCh(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_Yxy2Lab(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_CMC2XYZ(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_Lab2XYZ(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_XYZ2Lab(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_XYZ2scRGB(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_scRGB2sRGB(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_scRGB2BW(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_sRGB2scRGB(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_scRGB2XYZ(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_HSV2sRGB(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_sRGB2HSV(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_LCh2CMC(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_CMC2LCh(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_XYZ2Yxy(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_Yxy2XYZ(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_LabS2Lab(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_Lab2LabS(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_CMYK2XYZ(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_XYZ2CMYK(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_profile_load(
        name: *const ::std::os::raw::c_char,
        profile: *mut *mut VipsBlob,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_icc_present() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_icc_transform(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        output_profile: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_icc_import(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_icc_export(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_icc_ac2rc(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        profile_filename: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_icc_is_compatible_profile(
        image: *mut VipsImage,
        data: *const ::std::os::raw::c_void,
        data_length: usize,
    ) -> gboolean;
}
extern "C" {
    pub fn vips_dE76(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_dE00(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_dECMC(
        left: *mut VipsImage,
        right: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_col_Lab2XYZ(L: f32, a: f32, b: f32, X: *mut f32, Y: *mut f32, Z: *mut f32);
}
extern "C" {
    pub fn vips_col_XYZ2Lab(X: f32, Y: f32, Z: f32, L: *mut f32, a: *mut f32, b: *mut f32);
}
extern "C" {
    pub fn vips_col_ab2h(a: f64, b: f64) -> f64;
}
extern "C" {
    pub fn vips_col_ab2Ch(a: f32, b: f32, C: *mut f32, h: *mut f32);
}
extern "C" {
    pub fn vips_col_Ch2ab(C: f32, h: f32, a: *mut f32, b: *mut f32);
}
extern "C" {
    pub fn vips_col_L2Lcmc(L: f32) -> f32;
}
extern "C" {
    pub fn vips_col_C2Ccmc(C: f32) -> f32;
}
extern "C" {
    pub fn vips_col_Ch2hcmc(C: f32, h: f32) -> f32;
}
extern "C" {
    pub fn vips_col_make_tables_CMC();
}
extern "C" {
    pub fn vips_col_Lcmc2L(Lcmc: f32) -> f32;
}
extern "C" {
    pub fn vips_col_Ccmc2C(Ccmc: f32) -> f32;
}
extern "C" {
    pub fn vips_col_Chcmc2h(C: f32, hcmc: f32) -> f32;
}
extern "C" {
    pub fn vips_col_sRGB2scRGB_8(
        r: ::std::os::raw::c_int,
        g: ::std::os::raw::c_int,
        b: ::std::os::raw::c_int,
        R: *mut f32,
        G: *mut f32,
        B: *mut f32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_col_sRGB2scRGB_16(
        r: ::std::os::raw::c_int,
        g: ::std::os::raw::c_int,
        b: ::std::os::raw::c_int,
        R: *mut f32,
        G: *mut f32,
        B: *mut f32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_col_sRGB2scRGB_8_noclip(
        r: ::std::os::raw::c_int,
        g: ::std::os::raw::c_int,
        b: ::std::os::raw::c_int,
        R: *mut f32,
        G: *mut f32,
        B: *mut f32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_col_sRGB2scRGB_16_noclip(
        r: ::std::os::raw::c_int,
        g: ::std::os::raw::c_int,
        b: ::std::os::raw::c_int,
        R: *mut f32,
        G: *mut f32,
        B: *mut f32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_col_scRGB2XYZ(
        R: f32,
        G: f32,
        B: f32,
        X: *mut f32,
        Y: *mut f32,
        Z: *mut f32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_col_XYZ2scRGB(
        X: f32,
        Y: f32,
        Z: f32,
        R: *mut f32,
        G: *mut f32,
        B: *mut f32,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_col_scRGB2sRGB_8(
        R: f32,
        G: f32,
        B: f32,
        r: *mut ::std::os::raw::c_int,
        g: *mut ::std::os::raw::c_int,
        b: *mut ::std::os::raw::c_int,
        og: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_col_scRGB2sRGB_16(
        R: f32,
        G: f32,
        B: f32,
        r: *mut ::std::os::raw::c_int,
        g: *mut ::std::os::raw::c_int,
        b: *mut ::std::os::raw::c_int,
        og: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_col_scRGB2BW_16(
        R: f32,
        G: f32,
        B: f32,
        g: *mut ::std::os::raw::c_int,
        og: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_col_scRGB2BW_8(
        R: f32,
        G: f32,
        B: f32,
        g: *mut ::std::os::raw::c_int,
        og: *mut ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_pythagoras(L1: f32, a1: f32, b1: f32, L2: f32, a2: f32, b2: f32) -> f32;
}
extern "C" {
    pub fn vips_col_dE00(L1: f32, a1: f32, b1: f32, L2: f32, a2: f32, b2: f32) -> f32;
}
pub const VipsCombineMode_VIPS_COMBINE_MODE_SET: VipsCombineMode = 0;
pub const VipsCombineMode_VIPS_COMBINE_MODE_ADD: VipsCombineMode = 1;
pub const VipsCombineMode_VIPS_COMBINE_MODE_LAST: VipsCombineMode = 2;
pub type VipsCombineMode = u32;
extern "C" {
    pub fn vips_draw_rect(
        image: *mut VipsImage,
        ink: *mut f64,
        n: ::std::os::raw::c_int,
        left: ::std::os::raw::c_int,
        top: ::std::os::raw::c_int,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_draw_rect1(
        image: *mut VipsImage,
        ink: f64,
        left: ::std::os::raw::c_int,
        top: ::std::os::raw::c_int,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_draw_point(
        image: *mut VipsImage,
        ink: *mut f64,
        n: ::std::os::raw::c_int,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_draw_point1(
        image: *mut VipsImage,
        ink: f64,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_draw_image(
        image: *mut VipsImage,
        sub: *mut VipsImage,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_draw_mask(
        image: *mut VipsImage,
        ink: *mut f64,
        n: ::std::os::raw::c_int,
        mask: *mut VipsImage,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_draw_mask1(
        image: *mut VipsImage,
        ink: f64,
        mask: *mut VipsImage,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_draw_line(
        image: *mut VipsImage,
        ink: *mut f64,
        n: ::std::os::raw::c_int,
        x1: ::std::os::raw::c_int,
        y1: ::std::os::raw::c_int,
        x2: ::std::os::raw::c_int,
        y2: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_draw_line1(
        image: *mut VipsImage,
        ink: f64,
        x1: ::std::os::raw::c_int,
        y1: ::std::os::raw::c_int,
        x2: ::std::os::raw::c_int,
        y2: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_draw_circle(
        image: *mut VipsImage,
        ink: *mut f64,
        n: ::std::os::raw::c_int,
        cx: ::std::os::raw::c_int,
        cy: ::std::os::raw::c_int,
        radius: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_draw_circle1(
        image: *mut VipsImage,
        ink: f64,
        cx: ::std::os::raw::c_int,
        cy: ::std::os::raw::c_int,
        radius: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_draw_flood(
        image: *mut VipsImage,
        ink: *mut f64,
        n: ::std::os::raw::c_int,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_draw_flood1(
        image: *mut VipsImage,
        ink: f64,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_draw_smudge(
        image: *mut VipsImage,
        left: ::std::os::raw::c_int,
        top: ::std::os::raw::c_int,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_black(
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_xyz(
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_grey(
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_gaussmat(
        out: *mut *mut VipsImage,
        sigma: f64,
        min_ampl: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_logmat(
        out: *mut *mut VipsImage,
        sigma: f64,
        min_ampl: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_text(
        out: *mut *mut VipsImage,
        text: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_gaussnoise(
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_eye(
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_sines(
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_zone(
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_identity(out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_buildlut(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_invertlut(
        in_: *mut VipsImage,
        out: *mut *mut VipsImage,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_tonelut(out: *mut *mut VipsImage, ...) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_mask_ideal(
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        frequency_cutoff: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_mask_ideal_ring(
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        frequency_cutoff: f64,
        ringwidth: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_mask_ideal_band(
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        frequency_cutoff_x: f64,
        frequency_cutoff_y: f64,
        radius: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_mask_butterworth(
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        order: f64,
        frequency_cutoff: f64,
        amplitude_cutoff: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_mask_butterworth_ring(
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        order: f64,
        frequency_cutoff: f64,
        amplitude_cutoff: f64,
        ringwidth: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_mask_butterworth_band(
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        order: f64,
        frequency_cutoff_x: f64,
        frequency_cutoff_y: f64,
        radius: f64,
        amplitude_cutoff: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_mask_gaussian(
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        frequency_cutoff: f64,
        amplitude_cutoff: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_mask_gaussian_ring(
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        frequency_cutoff: f64,
        amplitude_cutoff: f64,
        ringwidth: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_mask_gaussian_band(
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        frequency_cutoff_x: f64,
        frequency_cutoff_y: f64,
        radius: f64,
        amplitude_cutoff: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_mask_fractal(
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        fractal_dimension: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_fractsurf(
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        fractal_dimension: f64,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_worley(
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_perlin(
        out: *mut *mut VipsImage,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_gmic(
        in_: *mut *mut VipsImage,
        out: *mut *mut VipsImage,
        n: ::std::os::raw::c_int,
        padding: ::std::os::raw::c_int,
        x_scale: f64,
        y_scale: f64,
        command: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_init(argv0: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_get_argv0() -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_shutdown();
}
extern "C" {
    pub fn vips_thread_shutdown();
}
extern "C" {
    pub fn vips_add_option_entries(option_group: *mut GOptionGroup);
}
extern "C" {
    pub fn vips_leak_set(leak: gboolean);
}
extern "C" {
    pub fn vips_version_string() -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_version(flag: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn vips_guess_prefix(
        argv0: *const ::std::os::raw::c_char,
        env_name: *const ::std::os::raw::c_char,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn vips_guess_libdir(
        argv0: *const ::std::os::raw::c_char,
        env_name: *const ::std::os::raw::c_char,
    ) -> *const ::std::os::raw::c_char;
}
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __va_list_tag {
    pub gp_offset: ::std::os::raw::c_uint,
    pub fp_offset: ::std::os::raw::c_uint,
    pub overflow_arg_area: *mut ::std::os::raw::c_void,
    pub reg_save_area: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout___va_list_tag() {
    assert_eq!(
        ::std::mem::size_of::<__va_list_tag>(),
        24usize,
        concat!("Size of: ", stringify!(__va_list_tag))
    );
    assert_eq!(
        ::std::mem::align_of::<__va_list_tag>(),
        8usize,
        concat!("Alignment of ", stringify!(__va_list_tag))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(gp_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(fp_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(overflow_arg_area)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(__va_list_tag),
            "::",
            stringify!(reg_save_area)
        )
    );
}
