/* automatically generated by rust-bindgen */

#![allow(clippy::all)]
#![allow(improper_ctypes)]

#[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 type intmax_t = ::std::os::raw::c_long;
pub type U8CPU = ::std::os::raw::c_uint;
pub type SkFourByteTag = u32;
pub type SkUnichar = i32;
pub type SkGlyphID = u16;
pub type SkMSec = u32;
#[repr(u8)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkBudgeted {
    kNo = 0,
    kYes = 1,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkBackingFit {
    kApprox = 0,
    kExact = 1,
}
pub type std_integral_constant_value_type<_Tp> = _Tp;
pub type std_integral_constant_type = u8;
pub type std_true_type = u8;
pub type std_false_type = u8;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std___and_ {
    pub _address: u8,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_is_empty {
    pub _address: u8,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_make_unsigned {
    pub _address: u8,
}
pub type std_make_unsigned_type = u8;
#[repr(C)]
#[derive(Copy, Clone)]
pub union std_aligned_storage_type {
    pub __data: *mut ::std::os::raw::c_uchar,
    pub __align: std_aligned_storage_type__bindgen_ty_1,
    _bindgen_union_align: u64,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_aligned_storage_type__bindgen_ty_1 {
    pub _address: u8,
}
#[test]
fn bindgen_test_layout_std_aligned_storage_type() {
    assert_eq!(
        ::core::mem::size_of::<std_aligned_storage_type>(),
        8usize,
        concat!("Size of: ", stringify!(std_aligned_storage_type))
    );
    assert_eq!(
        ::core::mem::align_of::<std_aligned_storage_type>(),
        8usize,
        concat!("Alignment of ", stringify!(std_aligned_storage_type))
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std___detector {
    pub _address: u8,
}
pub type std___detector_value_t = std_false_type;
pub type std___detector_type<_Default> = _Default;
pub type std___detected_or = std___detector;
pub type std___detected_or_t = std___detected_or;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_atomic {
    pub _address: u8,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_iterator {
    pub _address: u8,
}
pub type std_iterator_iterator_category<_Category> = _Category;
pub type std_iterator_value_type<_Tp> = _Tp;
pub type std_iterator_difference_type<_Distance> = _Distance;
pub type std_iterator_pointer<_Pointer> = _Pointer;
pub type std_iterator_reference<_Reference> = _Reference;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std___iterator_traits {
    pub _address: u8,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_iterator_traits {
    pub _address: u8,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std___undefined {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std___get_first_arg {
    pub _address: u8,
}
pub type std___get_first_arg_type = std___undefined;
pub type std___get_first_arg_t = std___get_first_arg;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std___replace_first_arg {
    pub _address: u8,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_pointer_traits {
    pub _address: u8,
}
pub type std_pointer_traits___element_type = [u8; 0usize];
pub type std_pointer_traits___difference_type = [u8; 0usize];
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_pointer_traits___rebind {
    pub _address: u8,
}
pub type std_pointer_traits_pointer<_Ptr> = _Ptr;
pub type std_pointer_traits_element_type = std___detected_or_t;
pub type std_pointer_traits_difference_type = std___detected_or_t;
pub type std_pointer_traits_rebind = std_pointer_traits___rebind;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_reverse_iterator<_Iterator> {
    pub current: _Iterator,
    pub _phantom_0: ::core::marker::PhantomData<::core::cell::UnsafeCell<_Iterator>>,
}
pub type std_reverse_iterator___traits_type = std_iterator_traits;
pub type std_reverse_iterator_iterator_type<_Iterator> = _Iterator;
pub type std_reverse_iterator_difference_type = std_reverse_iterator___traits_type;
pub type std_reverse_iterator_pointer = std_reverse_iterator___traits_type;
pub type std_reverse_iterator_reference = std_reverse_iterator___traits_type;
pub type std___allocator_base = __gnu_cxx_new_allocator;
#[repr(C)]
pub struct std_allocator {
    pub _address: u8,
}
pub type std_allocator_size_type = usize;
pub type std_allocator_difference_type = isize;
pub type std_allocator_pointer<_Tp> = *mut _Tp;
pub type std_allocator_const_pointer<_Tp> = *const _Tp;
pub type std_allocator_reference<_Tp> = *mut _Tp;
pub type std_allocator_const_reference<_Tp> = *const _Tp;
pub type std_allocator_value_type<_Tp> = _Tp;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_allocator_rebind {
    pub _address: u8,
}
pub type std_allocator_rebind_other = std_allocator;
pub type std_allocator_propagate_on_container_move_assignment = std_true_type;
pub type std_allocator_is_always_equal = std_true_type;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std___allocator_traits_base {
    pub _address: u8,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std___allocator_traits_base___rebind {
    pub _address: u8,
}
pub type std___allocator_traits_base___pointer = [u8; 0usize];
pub type std___allocator_traits_base___c_pointer = [u8; 0usize];
pub type std___allocator_traits_base___v_pointer = [u8; 0usize];
pub type std___allocator_traits_base___cv_pointer = [u8; 0usize];
pub type std___allocator_traits_base___pocca = [u8; 0usize];
pub type std___allocator_traits_base___pocma = [u8; 0usize];
pub type std___allocator_traits_base___pocs = [u8; 0usize];
pub type std___allocator_traits_base___equal = [u8; 0usize];
#[test]
fn bindgen_test_layout_std___allocator_traits_base() {
    assert_eq!(
        ::core::mem::size_of::<std___allocator_traits_base>(),
        1usize,
        concat!("Size of: ", stringify!(std___allocator_traits_base))
    );
    assert_eq!(
        ::core::mem::align_of::<std___allocator_traits_base>(),
        1usize,
        concat!("Alignment of ", stringify!(std___allocator_traits_base))
    );
}
pub type std___alloc_rebind = std___allocator_traits_base;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_allocator_traits {
    pub _address: u8,
}
pub type std_allocator_traits_allocator_type<_Alloc> = _Alloc;
pub type std_allocator_traits_value_type = [u8; 0usize];
pub type std_allocator_traits_pointer = std___detected_or_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_allocator_traits__Ptr {
    pub _address: u8,
}
pub type std_allocator_traits__Ptr_type = [u8; 0usize];
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_allocator_traits__Diff {
    pub _address: u8,
}
pub type std_allocator_traits__Diff_type = std_pointer_traits;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_allocator_traits__Size {
    pub _address: u8,
}
pub type std_allocator_traits_const_pointer = [u8; 0usize];
pub type std_allocator_traits_void_pointer = std_allocator_traits__Ptr;
pub type std_allocator_traits_const_void_pointer = std_allocator_traits__Ptr;
pub type std_allocator_traits_difference_type = [u8; 0usize];
pub type std_allocator_traits_size_type = [u8; 0usize];
pub type std_allocator_traits_propagate_on_container_copy_assignment = std___detected_or_t;
pub type std_allocator_traits_propagate_on_container_move_assignment = std___detected_or_t;
pub type std_allocator_traits_propagate_on_container_swap = std___detected_or_t;
pub type std_allocator_traits_is_always_equal = std___detected_or_t;
pub type std_allocator_traits_rebind_alloc = std___alloc_rebind;
pub type std_allocator_traits_rebind_traits = std_allocator_traits;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_allocator_traits___construct_helper {
    pub _address: u8,
}
pub type std_allocator_traits___construct_helper_type<_Alloc> = _Alloc;
pub type std_allocator_traits___has_construct = std_allocator_traits___construct_helper;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_tuple {
    pub _address: u8,
}
pub type std_tuple__Inherited = u8;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_tuple__TC2 {
    pub _address: u8,
}
pub type std_tuple__TCC = u8;
pub type std_tuple__TMC = u8;
pub type std_tuple__TMCT = u8;
pub type std_tuple__TNTC = u8;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_function {
    pub _address: u8,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_default_delete {
    pub _address: u8,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std___uniq_ptr_impl {
    pub _M_t: std_tuple,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std___uniq_ptr_impl__Ptr {
    pub _address: u8,
}
pub type std___uniq_ptr_impl__Ptr_type<_Up> = *mut _Up;
pub type std___uniq_ptr_impl__DeleterConstraint = u8;
pub type std___uniq_ptr_impl_pointer = std___uniq_ptr_impl__Ptr;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_unique_ptr {
    pub _address: u8,
}
pub type std_unique_ptr__DeleterConstraint = std___uniq_ptr_impl;
pub type std_unique_ptr_pointer = std___uniq_ptr_impl;
pub type std_unique_ptr_element_type<_Tp> = _Tp;
pub type std_unique_ptr_deleter_type<_Dp> = _Dp;
pub type std_unique_ptr___safe_conversion_up = std___and_;
extern "C" {
    #[link_name = "\u{1}num"]
    pub static std_ratio_num: intmax_t;
}
extern "C" {
    #[link_name = "\u{1}den"]
    pub static std_ratio_den: intmax_t;
}
pub type std_ratio_type = u8;
pub type std_milli = u8;
#[repr(C)]
pub struct std_chrono_duration<_Rep> {
    pub __r: std_chrono_duration_rep<_Rep>,
    pub _phantom_0: ::core::marker::PhantomData<::core::cell::UnsafeCell<_Rep>>,
}
pub type std_chrono_duration_rep<_Rep> = _Rep;
pub type std_chrono_duration_period<_Period> = _Period;
pub type std_chrono_milliseconds = std_chrono_duration<i64>;
#[repr(C)]
pub struct std__Vector_base {
    pub _M_impl: std__Vector_base__Vector_impl,
}
pub type std__Vector_base__Tp_alloc_type = __gnu_cxx___alloc_traits;
pub type std__Vector_base_pointer = __gnu_cxx___alloc_traits;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std__Vector_base__Vector_impl {
    pub _M_start: std__Vector_base_pointer,
    pub _M_finish: std__Vector_base_pointer,
    pub _M_end_of_storage: std__Vector_base_pointer,
}
pub type std__Vector_base_allocator_type<_Alloc> = _Alloc;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct std_vector {
    pub _address: u8,
}
pub type std_vector__Base = std__Vector_base;
pub type std_vector__Tp_alloc_type = std_vector__Base;
pub type std_vector__Alloc_traits = __gnu_cxx___alloc_traits;
pub type std_vector_value_type<_Tp> = _Tp;
pub type std_vector_pointer = std_vector__Base;
pub type std_vector_const_pointer = std_vector__Alloc_traits;
pub type std_vector_reference = std_vector__Alloc_traits;
pub type std_vector_const_reference = std_vector__Alloc_traits;
pub type std_vector_iterator = __gnu_cxx___normal_iterator<std_vector_pointer>;
pub type std_vector_const_iterator = __gnu_cxx___normal_iterator<std_vector_const_pointer>;
pub type std_vector_const_reverse_iterator = std_reverse_iterator<std_vector_const_iterator>;
pub type std_vector_reverse_iterator = std_reverse_iterator<std_vector_iterator>;
pub type std_vector_size_type = usize;
pub type std_vector_difference_type = isize;
pub type std_vector_allocator_type<_Alloc> = _Alloc;
#[repr(C)]
pub struct std_vector__Temporary_value {
    pub _M_this: *mut u8,
    pub __buf: u8,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __gnu_cxx___normal_iterator<_Iterator> {
    pub _M_current: _Iterator,
    pub _phantom_0: ::core::marker::PhantomData<::core::cell::UnsafeCell<_Iterator>>,
}
pub type __gnu_cxx___normal_iterator___traits_type = std_iterator_traits;
pub type __gnu_cxx___normal_iterator_iterator_type<_Iterator> = _Iterator;
pub type __gnu_cxx___normal_iterator_iterator_category = __gnu_cxx___normal_iterator___traits_type;
pub type __gnu_cxx___normal_iterator_value_type = __gnu_cxx___normal_iterator___traits_type;
pub type __gnu_cxx___normal_iterator_difference_type = __gnu_cxx___normal_iterator___traits_type;
pub type __gnu_cxx___normal_iterator_reference = __gnu_cxx___normal_iterator___traits_type;
pub type __gnu_cxx___normal_iterator_pointer = __gnu_cxx___normal_iterator___traits_type;
#[repr(C)]
pub struct __gnu_cxx_new_allocator {
    pub _address: u8,
}
pub type __gnu_cxx_new_allocator_size_type = usize;
pub type __gnu_cxx_new_allocator_difference_type = isize;
pub type __gnu_cxx_new_allocator_pointer<_Tp> = *mut _Tp;
pub type __gnu_cxx_new_allocator_const_pointer<_Tp> = *const _Tp;
pub type __gnu_cxx_new_allocator_reference<_Tp> = *mut _Tp;
pub type __gnu_cxx_new_allocator_const_reference<_Tp> = *const _Tp;
pub type __gnu_cxx_new_allocator_value_type<_Tp> = _Tp;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __gnu_cxx_new_allocator_rebind {
    pub _address: u8,
}
pub type __gnu_cxx_new_allocator_rebind_other = __gnu_cxx_new_allocator;
pub type __gnu_cxx_new_allocator_propagate_on_container_move_assignment = std_true_type;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __gnu_cxx___alloc_traits {
    pub _address: u8,
}
pub type __gnu_cxx___alloc_traits_allocator_type<_Alloc> = _Alloc;
pub type __gnu_cxx___alloc_traits__Base_type = std_allocator_traits;
pub type __gnu_cxx___alloc_traits_value_type = __gnu_cxx___alloc_traits__Base_type;
pub type __gnu_cxx___alloc_traits_pointer = __gnu_cxx___alloc_traits__Base_type;
pub type __gnu_cxx___alloc_traits_const_pointer = __gnu_cxx___alloc_traits__Base_type;
pub type __gnu_cxx___alloc_traits_size_type = __gnu_cxx___alloc_traits__Base_type;
pub type __gnu_cxx___alloc_traits_difference_type = __gnu_cxx___alloc_traits__Base_type;
pub type __gnu_cxx___alloc_traits_reference = *mut __gnu_cxx___alloc_traits_value_type;
pub type __gnu_cxx___alloc_traits_const_reference = *const __gnu_cxx___alloc_traits_value_type;
pub type __gnu_cxx___alloc_traits___is_custom_pointer = std___and_;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __gnu_cxx___alloc_traits_rebind {
    pub _address: u8,
}
pub type __gnu_cxx___alloc_traits_rebind_other = __gnu_cxx___alloc_traits__Base_type;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
pub type SkScalar = f32;
pub type SkIVector = SkIPoint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkIPoint {
    pub fX: i32,
    pub fY: i32,
}
#[test]
fn bindgen_test_layout_SkIPoint() {
    assert_eq!(
        ::core::mem::size_of::<SkIPoint>(),
        8usize,
        concat!("Size of: ", stringify!(SkIPoint))
    );
    assert_eq!(
        ::core::mem::align_of::<SkIPoint>(),
        4usize,
        concat!("Alignment of ", stringify!(SkIPoint))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkIPoint>())).fX as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkIPoint),
            "::",
            stringify!(fX)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkIPoint>())).fY as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkIPoint),
            "::",
            stringify!(fY)
        )
    );
}
pub type SkVector = SkPoint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkPoint {
    pub fX: SkScalar,
    pub fY: SkScalar,
}
#[test]
fn bindgen_test_layout_SkPoint() {
    assert_eq!(
        ::core::mem::size_of::<SkPoint>(),
        8usize,
        concat!("Size of: ", stringify!(SkPoint))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPoint>(),
        4usize,
        concat!("Alignment of ", stringify!(SkPoint))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPoint>())).fX as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPoint),
            "::",
            stringify!(fX)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPoint>())).fY as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPoint),
            "::",
            stringify!(fY)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPoint9normalizeEv"]
    pub fn SkPoint_normalize(this: *mut SkPoint) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPoint12setNormalizeEff"]
    pub fn SkPoint_setNormalize(this: *mut SkPoint, x: SkScalar, y: SkScalar) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPoint9setLengthEf"]
    pub fn SkPoint_setLength(this: *mut SkPoint, length: SkScalar) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPoint9setLengthEfff"]
    pub fn SkPoint_setLength1(
        this: *mut SkPoint,
        x: SkScalar,
        y: SkScalar,
        length: SkScalar,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkPoint5scaleEfPS_"]
    pub fn SkPoint_scale(this: *const SkPoint, scale: SkScalar, dst: *mut SkPoint);
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPoint6LengthEff"]
    pub fn SkPoint_Length(x: SkScalar, y: SkScalar) -> SkScalar;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPoint9NormalizeEPS_"]
    pub fn SkPoint_Normalize(vec: *mut SkVector) -> SkScalar;
}
impl SkPoint {
    #[inline]
    pub unsafe fn normalize(&mut self) -> bool {
        SkPoint_normalize(self)
    }
    #[inline]
    pub unsafe fn setNormalize(&mut self, x: SkScalar, y: SkScalar) -> bool {
        SkPoint_setNormalize(self, x, y)
    }
    #[inline]
    pub unsafe fn setLength(&mut self, length: SkScalar) -> bool {
        SkPoint_setLength(self, length)
    }
    #[inline]
    pub unsafe fn setLength1(&mut self, x: SkScalar, y: SkScalar, length: SkScalar) -> bool {
        SkPoint_setLength1(self, x, y, length)
    }
    #[inline]
    pub unsafe fn scale(&self, scale: SkScalar, dst: *mut SkPoint) {
        SkPoint_scale(self, scale, dst)
    }
    #[inline]
    pub unsafe fn Length(x: SkScalar, y: SkScalar) -> SkScalar {
        SkPoint_Length(x, y)
    }
    #[inline]
    pub unsafe fn Normalize(vec: *mut SkVector) -> SkScalar {
        SkPoint_Normalize(vec)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkISize {
    pub fWidth: i32,
    pub fHeight: i32,
}
#[test]
fn bindgen_test_layout_SkISize() {
    assert_eq!(
        ::core::mem::size_of::<SkISize>(),
        8usize,
        concat!("Size of: ", stringify!(SkISize))
    );
    assert_eq!(
        ::core::mem::align_of::<SkISize>(),
        4usize,
        concat!("Alignment of ", stringify!(SkISize))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkISize>())).fWidth as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkISize),
            "::",
            stringify!(fWidth)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkISize>())).fHeight as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkISize),
            "::",
            stringify!(fHeight)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkSize {
    pub fWidth: SkScalar,
    pub fHeight: SkScalar,
}
#[test]
fn bindgen_test_layout_SkSize() {
    assert_eq!(
        ::core::mem::size_of::<SkSize>(),
        8usize,
        concat!("Size of: ", stringify!(SkSize))
    );
    assert_eq!(
        ::core::mem::align_of::<SkSize>(),
        4usize,
        concat!("Alignment of ", stringify!(SkSize))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkSize>())).fWidth as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkSize),
            "::",
            stringify!(fWidth)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkSize>())).fHeight as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkSize),
            "::",
            stringify!(fHeight)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkIRect {
    pub fLeft: i32,
    pub fTop: i32,
    pub fRight: i32,
    pub fBottom: i32,
}
#[test]
fn bindgen_test_layout_SkIRect() {
    assert_eq!(
        ::core::mem::size_of::<SkIRect>(),
        16usize,
        concat!("Size of: ", stringify!(SkIRect))
    );
    assert_eq!(
        ::core::mem::align_of::<SkIRect>(),
        4usize,
        concat!("Alignment of ", stringify!(SkIRect))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkIRect>())).fLeft as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkIRect),
            "::",
            stringify!(fLeft)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkIRect>())).fTop as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkIRect),
            "::",
            stringify!(fTop)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkIRect>())).fRight as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkIRect),
            "::",
            stringify!(fRight)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkIRect>())).fBottom as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(SkIRect),
            "::",
            stringify!(fBottom)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkIRect8containsERK6SkRect"]
    pub fn SkIRect_contains(this: *const SkIRect, r: *const SkRect) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkIRect4joinEiiii"]
    pub fn SkIRect_join(this: *mut SkIRect, left: i32, top: i32, right: i32, bottom: i32);
}
impl SkIRect {
    #[inline]
    pub unsafe fn contains(&self, r: *const SkRect) -> bool {
        SkIRect_contains(self, r)
    }
    #[inline]
    pub unsafe fn join(&mut self, left: i32, top: i32, right: i32, bottom: i32) {
        SkIRect_join(self, left, top, right, bottom)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkRect {
    pub fLeft: SkScalar,
    pub fTop: SkScalar,
    pub fRight: SkScalar,
    pub fBottom: SkScalar,
}
#[test]
fn bindgen_test_layout_SkRect() {
    assert_eq!(
        ::core::mem::size_of::<SkRect>(),
        16usize,
        concat!("Size of: ", stringify!(SkRect))
    );
    assert_eq!(
        ::core::mem::align_of::<SkRect>(),
        4usize,
        concat!("Alignment of ", stringify!(SkRect))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRect>())).fLeft as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRect),
            "::",
            stringify!(fLeft)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRect>())).fTop as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRect),
            "::",
            stringify!(fTop)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRect>())).fRight as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRect),
            "::",
            stringify!(fRight)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRect>())).fBottom as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRect),
            "::",
            stringify!(fBottom)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkRect6toQuadEP7SkPoint"]
    pub fn SkRect_toQuad(this: *const SkRect, quad: *mut SkPoint);
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkRect14setBoundsCheckEPK7SkPointi"]
    pub fn SkRect_setBoundsCheck(
        this: *mut SkRect,
        pts: *const SkPoint,
        count: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkRect16setBoundsNoCheckEPK7SkPointi"]
    pub fn SkRect_setBoundsNoCheck(
        this: *mut SkRect,
        pts: *const SkPoint,
        count: ::std::os::raw::c_int,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkRect9intersectERKS_"]
    pub fn SkRect_intersect(this: *mut SkRect, r: *const SkRect) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkRect9intersectEffff"]
    pub fn SkRect_intersect1(
        this: *mut SkRect,
        left: SkScalar,
        top: SkScalar,
        right: SkScalar,
        bottom: SkScalar,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkRect9intersectERKS_S1_"]
    pub fn SkRect_intersect2(this: *mut SkRect, a: *const SkRect, b: *const SkRect) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkRect4joinEffff"]
    pub fn SkRect_join(
        this: *mut SkRect,
        left: SkScalar,
        top: SkScalar,
        right: SkScalar,
        bottom: SkScalar,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkRect4dumpEb"]
    pub fn SkRect_dump(this: *const SkRect, asHex: bool);
}
impl SkRect {
    #[inline]
    pub unsafe fn toQuad(&self, quad: *mut SkPoint) {
        SkRect_toQuad(self, quad)
    }
    #[inline]
    pub unsafe fn setBoundsCheck(
        &mut self,
        pts: *const SkPoint,
        count: ::std::os::raw::c_int,
    ) -> bool {
        SkRect_setBoundsCheck(self, pts, count)
    }
    #[inline]
    pub unsafe fn setBoundsNoCheck(&mut self, pts: *const SkPoint, count: ::std::os::raw::c_int) {
        SkRect_setBoundsNoCheck(self, pts, count)
    }
    #[inline]
    pub unsafe fn intersect(&mut self, r: *const SkRect) -> bool {
        SkRect_intersect(self, r)
    }
    #[inline]
    pub unsafe fn intersect1(
        &mut self,
        left: SkScalar,
        top: SkScalar,
        right: SkScalar,
        bottom: SkScalar,
    ) -> bool {
        SkRect_intersect1(self, left, top, right, bottom)
    }
    #[inline]
    pub unsafe fn intersect2(&mut self, a: *const SkRect, b: *const SkRect) -> bool {
        SkRect_intersect2(self, a, b)
    }
    #[inline]
    pub unsafe fn join(
        &mut self,
        left: SkScalar,
        top: SkScalar,
        right: SkScalar,
        bottom: SkScalar,
    ) {
        SkRect_join(self, left, top, right, bottom)
    }
    #[inline]
    pub unsafe fn dump(&self, asHex: bool) {
        SkRect_dump(self, asHex)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkMatrix {
    pub fMat: [SkScalar; 9usize],
    pub fTypeMask: u32,
}
pub const SkMatrix_TypeMask_kIdentity_Mask: SkMatrix_TypeMask = 0;
pub const SkMatrix_TypeMask_kTranslate_Mask: SkMatrix_TypeMask = 1;
pub const SkMatrix_TypeMask_kScale_Mask: SkMatrix_TypeMask = 2;
pub const SkMatrix_TypeMask_kAffine_Mask: SkMatrix_TypeMask = 4;
pub const SkMatrix_TypeMask_kPerspective_Mask: SkMatrix_TypeMask = 8;
pub type SkMatrix_TypeMask = u32;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkMatrix_ScaleToFit {
    kFill_ScaleToFit = 0,
    kStart_ScaleToFit = 1,
    kCenter_ScaleToFit = 2,
    kEnd_ScaleToFit = 3,
}
pub type SkMatrix_MapXYProc = ::core::option::Option<
    unsafe extern "C" fn(mat: *const SkMatrix, x: SkScalar, y: SkScalar, result: *mut SkPoint),
>;
pub type SkMatrix_MapPtsProc = ::core::option::Option<
    unsafe extern "C" fn(
        mat: *const SkMatrix,
        dst: *mut SkPoint,
        src: *const SkPoint,
        count: ::std::os::raw::c_int,
    ),
>;
pub const SkMatrix_kMScaleX: ::std::os::raw::c_int = 0;
pub const SkMatrix_kMSkewX: ::std::os::raw::c_int = 1;
pub const SkMatrix_kMTransX: ::std::os::raw::c_int = 2;
pub const SkMatrix_kMSkewY: ::std::os::raw::c_int = 3;
pub const SkMatrix_kMScaleY: ::std::os::raw::c_int = 4;
pub const SkMatrix_kMTransY: ::std::os::raw::c_int = 5;
pub const SkMatrix_kMPersp0: ::std::os::raw::c_int = 6;
pub const SkMatrix_kMPersp1: ::std::os::raw::c_int = 7;
pub const SkMatrix_kMPersp2: ::std::os::raw::c_int = 8;
pub const SkMatrix_kAScaleX: ::std::os::raw::c_int = 0;
pub const SkMatrix_kASkewY: ::std::os::raw::c_int = 1;
pub const SkMatrix_kASkewX: ::std::os::raw::c_int = 2;
pub const SkMatrix_kAScaleY: ::std::os::raw::c_int = 3;
pub const SkMatrix_kATransX: ::std::os::raw::c_int = 4;
pub const SkMatrix_kATransY: ::std::os::raw::c_int = 5;
pub const SkMatrix_kRectStaysRect_Mask: ::std::os::raw::c_int = 16;
pub const SkMatrix_kOnlyPerspectiveValid_Mask: ::std::os::raw::c_int = 64;
pub const SkMatrix_kUnknown_Mask: ::std::os::raw::c_int = 128;
pub const SkMatrix_kORableMasks: ::std::os::raw::c_int = 15;
pub const SkMatrix_kAllMasks: ::std::os::raw::c_int = 31;
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix11gMapXYProcsE"]
    pub static mut SkMatrix_gMapXYProcs: [SkMatrix_MapXYProc; 0usize];
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix12gMapPtsProcsE"]
    pub static mut SkMatrix_gMapPtsProcs: [SkMatrix_MapPtsProc; 0usize];
}
#[test]
fn bindgen_test_layout_SkMatrix() {
    assert_eq!(
        ::core::mem::size_of::<SkMatrix>(),
        40usize,
        concat!("Size of: ", stringify!(SkMatrix))
    );
    assert_eq!(
        ::core::mem::align_of::<SkMatrix>(),
        4usize,
        concat!("Alignment of ", stringify!(SkMatrix))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkMatrix>())).fMat as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkMatrix),
            "::",
            stringify!(fMat)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkMatrix>())).fTypeMask as *const _ as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(SkMatrix),
            "::",
            stringify!(fTypeMask)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkMatrix12isSimilarityEf"]
    pub fn SkMatrix_isSimilarity(this: *const SkMatrix, tol: SkScalar) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkMatrix20preservesRightAnglesEf"]
    pub fn SkMatrix_preservesRightAngles(this: *const SkMatrix, tol: SkScalar) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix4set9EPKf"]
    pub fn SkMatrix_set9(this: *mut SkMatrix, buffer: *const SkScalar) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix5resetEv"]
    pub fn SkMatrix_reset(this: *mut SkMatrix) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix12setTranslateEff"]
    pub fn SkMatrix_setTranslate(this: *mut SkMatrix, dx: SkScalar, dy: SkScalar) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix8setScaleEffff"]
    pub fn SkMatrix_setScale(
        this: *mut SkMatrix,
        sx: SkScalar,
        sy: SkScalar,
        px: SkScalar,
        py: SkScalar,
    ) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix8setScaleEff"]
    pub fn SkMatrix_setScale1(this: *mut SkMatrix, sx: SkScalar, sy: SkScalar) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix9setRotateEfff"]
    pub fn SkMatrix_setRotate(
        this: *mut SkMatrix,
        degrees: SkScalar,
        px: SkScalar,
        py: SkScalar,
    ) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix9setRotateEf"]
    pub fn SkMatrix_setRotate1(this: *mut SkMatrix, degrees: SkScalar) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix9setSinCosEffff"]
    pub fn SkMatrix_setSinCos(
        this: *mut SkMatrix,
        sinValue: SkScalar,
        cosValue: SkScalar,
        px: SkScalar,
        py: SkScalar,
    ) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix9setSinCosEff"]
    pub fn SkMatrix_setSinCos1(
        this: *mut SkMatrix,
        sinValue: SkScalar,
        cosValue: SkScalar,
    ) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix10setRSXformERK9SkRSXform"]
    pub fn SkMatrix_setRSXform(this: *mut SkMatrix, rsxForm: *const SkRSXform) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix7setSkewEffff"]
    pub fn SkMatrix_setSkew(
        this: *mut SkMatrix,
        kx: SkScalar,
        ky: SkScalar,
        px: SkScalar,
        py: SkScalar,
    ) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix7setSkewEff"]
    pub fn SkMatrix_setSkew1(this: *mut SkMatrix, kx: SkScalar, ky: SkScalar) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix9setConcatERKS_S1_"]
    pub fn SkMatrix_setConcat(
        this: *mut SkMatrix,
        a: *const SkMatrix,
        b: *const SkMatrix,
    ) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix12preTranslateEff"]
    pub fn SkMatrix_preTranslate(this: *mut SkMatrix, dx: SkScalar, dy: SkScalar) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix8preScaleEffff"]
    pub fn SkMatrix_preScale(
        this: *mut SkMatrix,
        sx: SkScalar,
        sy: SkScalar,
        px: SkScalar,
        py: SkScalar,
    ) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix8preScaleEff"]
    pub fn SkMatrix_preScale1(this: *mut SkMatrix, sx: SkScalar, sy: SkScalar) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix9preRotateEfff"]
    pub fn SkMatrix_preRotate(
        this: *mut SkMatrix,
        degrees: SkScalar,
        px: SkScalar,
        py: SkScalar,
    ) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix9preRotateEf"]
    pub fn SkMatrix_preRotate1(this: *mut SkMatrix, degrees: SkScalar) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix7preSkewEffff"]
    pub fn SkMatrix_preSkew(
        this: *mut SkMatrix,
        kx: SkScalar,
        ky: SkScalar,
        px: SkScalar,
        py: SkScalar,
    ) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix7preSkewEff"]
    pub fn SkMatrix_preSkew1(this: *mut SkMatrix, kx: SkScalar, ky: SkScalar) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix9preConcatERKS_"]
    pub fn SkMatrix_preConcat(this: *mut SkMatrix, other: *const SkMatrix) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix13postTranslateEff"]
    pub fn SkMatrix_postTranslate(this: *mut SkMatrix, dx: SkScalar, dy: SkScalar)
        -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix9postScaleEffff"]
    pub fn SkMatrix_postScale(
        this: *mut SkMatrix,
        sx: SkScalar,
        sy: SkScalar,
        px: SkScalar,
        py: SkScalar,
    ) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix9postScaleEff"]
    pub fn SkMatrix_postScale1(this: *mut SkMatrix, sx: SkScalar, sy: SkScalar) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix8postIDivEii"]
    pub fn SkMatrix_postIDiv(
        this: *mut SkMatrix,
        divx: ::std::os::raw::c_int,
        divy: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix10postRotateEfff"]
    pub fn SkMatrix_postRotate(
        this: *mut SkMatrix,
        degrees: SkScalar,
        px: SkScalar,
        py: SkScalar,
    ) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix10postRotateEf"]
    pub fn SkMatrix_postRotate1(this: *mut SkMatrix, degrees: SkScalar) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix8postSkewEffff"]
    pub fn SkMatrix_postSkew(
        this: *mut SkMatrix,
        kx: SkScalar,
        ky: SkScalar,
        px: SkScalar,
        py: SkScalar,
    ) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix8postSkewEff"]
    pub fn SkMatrix_postSkew1(this: *mut SkMatrix, kx: SkScalar, ky: SkScalar) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix10postConcatERKS_"]
    pub fn SkMatrix_postConcat(this: *mut SkMatrix, other: *const SkMatrix) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix13setRectToRectERK6SkRectS2_NS_10ScaleToFitE"]
    pub fn SkMatrix_setRectToRect(
        this: *mut SkMatrix,
        src: *const SkRect,
        dst: *const SkRect,
        stf: SkMatrix_ScaleToFit,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix13setPolyToPolyEPK7SkPointS2_i"]
    pub fn SkMatrix_setPolyToPoly(
        this: *mut SkMatrix,
        src: *const SkPoint,
        dst: *const SkPoint,
        count: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix17SetAffineIdentityEPf"]
    pub fn SkMatrix_SetAffineIdentity(affine: *mut SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkMatrix8asAffineEPf"]
    pub fn SkMatrix_asAffine(this: *const SkMatrix, affine: *mut SkScalar) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix9setAffineEPKf"]
    pub fn SkMatrix_setAffine(this: *mut SkMatrix, affine: *const SkScalar) -> *mut SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkMatrix9mapPointsEP7SkPointPKS0_i"]
    pub fn SkMatrix_mapPoints(
        this: *const SkMatrix,
        dst: *mut SkPoint,
        src: *const SkPoint,
        count: ::std::os::raw::c_int,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkMatrix20mapHomogeneousPointsEP8SkPoint3PKS0_i"]
    pub fn SkMatrix_mapHomogeneousPoints(
        this: *const SkMatrix,
        dst: *mut SkPoint3,
        src: *const SkPoint3,
        count: ::std::os::raw::c_int,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkMatrix5mapXYEffP7SkPoint"]
    pub fn SkMatrix_mapXY(this: *const SkMatrix, x: SkScalar, y: SkScalar, result: *mut SkPoint);
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkMatrix10mapVectorsEP7SkPointPKS0_i"]
    pub fn SkMatrix_mapVectors(
        this: *const SkMatrix,
        dst: *mut SkVector,
        src: *const SkVector,
        count: ::std::os::raw::c_int,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkMatrix7mapRectEP6SkRectRKS0_"]
    pub fn SkMatrix_mapRect(this: *const SkMatrix, dst: *mut SkRect, src: *const SkRect) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkMatrix21mapRectScaleTranslateEP6SkRectRKS0_"]
    pub fn SkMatrix_mapRectScaleTranslate(
        this: *const SkMatrix,
        dst: *mut SkRect,
        src: *const SkRect,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkMatrix9mapRadiusEf"]
    pub fn SkMatrix_mapRadius(this: *const SkMatrix, radius: SkScalar) -> SkScalar;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkMatrix14isFixedStepInXEv"]
    pub fn SkMatrix_isFixedStepInX(this: *const SkMatrix) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkMatrix12fixedStepInXEf"]
    pub fn SkMatrix_fixedStepInX(this: *const SkMatrix, y: SkScalar) -> SkVector;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkMatrix4dumpEv"]
    pub fn SkMatrix_dump(this: *const SkMatrix);
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkMatrix11getMinScaleEv"]
    pub fn SkMatrix_getMinScale(this: *const SkMatrix) -> SkScalar;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkMatrix11getMaxScaleEv"]
    pub fn SkMatrix_getMaxScale(this: *const SkMatrix) -> SkScalar;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkMatrix15getMinMaxScalesEPf"]
    pub fn SkMatrix_getMinMaxScales(this: *const SkMatrix, scaleFactors: *mut SkScalar) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkMatrix14decomposeScaleEP6SkSizePS_"]
    pub fn SkMatrix_decomposeScale(
        this: *const SkMatrix,
        scale: *mut SkSize,
        remaining: *mut SkMatrix,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix1IEv"]
    pub fn SkMatrix_I() -> *const SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkMatrix13InvalidMatrixEv"]
    pub fn SkMatrix_InvalidMatrix() -> *const SkMatrix;
}
impl SkMatrix {
    #[inline]
    pub unsafe fn isSimilarity(&self, tol: SkScalar) -> bool {
        SkMatrix_isSimilarity(self, tol)
    }
    #[inline]
    pub unsafe fn preservesRightAngles(&self, tol: SkScalar) -> bool {
        SkMatrix_preservesRightAngles(self, tol)
    }
    #[inline]
    pub unsafe fn set9(&mut self, buffer: *const SkScalar) -> *mut SkMatrix {
        SkMatrix_set9(self, buffer)
    }
    #[inline]
    pub unsafe fn reset(&mut self) -> *mut SkMatrix {
        SkMatrix_reset(self)
    }
    #[inline]
    pub unsafe fn setTranslate(&mut self, dx: SkScalar, dy: SkScalar) -> *mut SkMatrix {
        SkMatrix_setTranslate(self, dx, dy)
    }
    #[inline]
    pub unsafe fn setScale(
        &mut self,
        sx: SkScalar,
        sy: SkScalar,
        px: SkScalar,
        py: SkScalar,
    ) -> *mut SkMatrix {
        SkMatrix_setScale(self, sx, sy, px, py)
    }
    #[inline]
    pub unsafe fn setScale1(&mut self, sx: SkScalar, sy: SkScalar) -> *mut SkMatrix {
        SkMatrix_setScale1(self, sx, sy)
    }
    #[inline]
    pub unsafe fn setRotate(
        &mut self,
        degrees: SkScalar,
        px: SkScalar,
        py: SkScalar,
    ) -> *mut SkMatrix {
        SkMatrix_setRotate(self, degrees, px, py)
    }
    #[inline]
    pub unsafe fn setRotate1(&mut self, degrees: SkScalar) -> *mut SkMatrix {
        SkMatrix_setRotate1(self, degrees)
    }
    #[inline]
    pub unsafe fn setSinCos(
        &mut self,
        sinValue: SkScalar,
        cosValue: SkScalar,
        px: SkScalar,
        py: SkScalar,
    ) -> *mut SkMatrix {
        SkMatrix_setSinCos(self, sinValue, cosValue, px, py)
    }
    #[inline]
    pub unsafe fn setSinCos1(&mut self, sinValue: SkScalar, cosValue: SkScalar) -> *mut SkMatrix {
        SkMatrix_setSinCos1(self, sinValue, cosValue)
    }
    #[inline]
    pub unsafe fn setRSXform(&mut self, rsxForm: *const SkRSXform) -> *mut SkMatrix {
        SkMatrix_setRSXform(self, rsxForm)
    }
    #[inline]
    pub unsafe fn setSkew(
        &mut self,
        kx: SkScalar,
        ky: SkScalar,
        px: SkScalar,
        py: SkScalar,
    ) -> *mut SkMatrix {
        SkMatrix_setSkew(self, kx, ky, px, py)
    }
    #[inline]
    pub unsafe fn setSkew1(&mut self, kx: SkScalar, ky: SkScalar) -> *mut SkMatrix {
        SkMatrix_setSkew1(self, kx, ky)
    }
    #[inline]
    pub unsafe fn setConcat(&mut self, a: *const SkMatrix, b: *const SkMatrix) -> *mut SkMatrix {
        SkMatrix_setConcat(self, a, b)
    }
    #[inline]
    pub unsafe fn preTranslate(&mut self, dx: SkScalar, dy: SkScalar) -> *mut SkMatrix {
        SkMatrix_preTranslate(self, dx, dy)
    }
    #[inline]
    pub unsafe fn preScale(
        &mut self,
        sx: SkScalar,
        sy: SkScalar,
        px: SkScalar,
        py: SkScalar,
    ) -> *mut SkMatrix {
        SkMatrix_preScale(self, sx, sy, px, py)
    }
    #[inline]
    pub unsafe fn preScale1(&mut self, sx: SkScalar, sy: SkScalar) -> *mut SkMatrix {
        SkMatrix_preScale1(self, sx, sy)
    }
    #[inline]
    pub unsafe fn preRotate(
        &mut self,
        degrees: SkScalar,
        px: SkScalar,
        py: SkScalar,
    ) -> *mut SkMatrix {
        SkMatrix_preRotate(self, degrees, px, py)
    }
    #[inline]
    pub unsafe fn preRotate1(&mut self, degrees: SkScalar) -> *mut SkMatrix {
        SkMatrix_preRotate1(self, degrees)
    }
    #[inline]
    pub unsafe fn preSkew(
        &mut self,
        kx: SkScalar,
        ky: SkScalar,
        px: SkScalar,
        py: SkScalar,
    ) -> *mut SkMatrix {
        SkMatrix_preSkew(self, kx, ky, px, py)
    }
    #[inline]
    pub unsafe fn preSkew1(&mut self, kx: SkScalar, ky: SkScalar) -> *mut SkMatrix {
        SkMatrix_preSkew1(self, kx, ky)
    }
    #[inline]
    pub unsafe fn preConcat(&mut self, other: *const SkMatrix) -> *mut SkMatrix {
        SkMatrix_preConcat(self, other)
    }
    #[inline]
    pub unsafe fn postTranslate(&mut self, dx: SkScalar, dy: SkScalar) -> *mut SkMatrix {
        SkMatrix_postTranslate(self, dx, dy)
    }
    #[inline]
    pub unsafe fn postScale(
        &mut self,
        sx: SkScalar,
        sy: SkScalar,
        px: SkScalar,
        py: SkScalar,
    ) -> *mut SkMatrix {
        SkMatrix_postScale(self, sx, sy, px, py)
    }
    #[inline]
    pub unsafe fn postScale1(&mut self, sx: SkScalar, sy: SkScalar) -> *mut SkMatrix {
        SkMatrix_postScale1(self, sx, sy)
    }
    #[inline]
    pub unsafe fn postIDiv(
        &mut self,
        divx: ::std::os::raw::c_int,
        divy: ::std::os::raw::c_int,
    ) -> bool {
        SkMatrix_postIDiv(self, divx, divy)
    }
    #[inline]
    pub unsafe fn postRotate(
        &mut self,
        degrees: SkScalar,
        px: SkScalar,
        py: SkScalar,
    ) -> *mut SkMatrix {
        SkMatrix_postRotate(self, degrees, px, py)
    }
    #[inline]
    pub unsafe fn postRotate1(&mut self, degrees: SkScalar) -> *mut SkMatrix {
        SkMatrix_postRotate1(self, degrees)
    }
    #[inline]
    pub unsafe fn postSkew(
        &mut self,
        kx: SkScalar,
        ky: SkScalar,
        px: SkScalar,
        py: SkScalar,
    ) -> *mut SkMatrix {
        SkMatrix_postSkew(self, kx, ky, px, py)
    }
    #[inline]
    pub unsafe fn postSkew1(&mut self, kx: SkScalar, ky: SkScalar) -> *mut SkMatrix {
        SkMatrix_postSkew1(self, kx, ky)
    }
    #[inline]
    pub unsafe fn postConcat(&mut self, other: *const SkMatrix) -> *mut SkMatrix {
        SkMatrix_postConcat(self, other)
    }
    #[inline]
    pub unsafe fn setRectToRect(
        &mut self,
        src: *const SkRect,
        dst: *const SkRect,
        stf: SkMatrix_ScaleToFit,
    ) -> bool {
        SkMatrix_setRectToRect(self, src, dst, stf)
    }
    #[inline]
    pub unsafe fn setPolyToPoly(
        &mut self,
        src: *const SkPoint,
        dst: *const SkPoint,
        count: ::std::os::raw::c_int,
    ) -> bool {
        SkMatrix_setPolyToPoly(self, src, dst, count)
    }
    #[inline]
    pub unsafe fn SetAffineIdentity(affine: *mut SkScalar) {
        SkMatrix_SetAffineIdentity(affine)
    }
    #[inline]
    pub unsafe fn asAffine(&self, affine: *mut SkScalar) -> bool {
        SkMatrix_asAffine(self, affine)
    }
    #[inline]
    pub unsafe fn setAffine(&mut self, affine: *const SkScalar) -> *mut SkMatrix {
        SkMatrix_setAffine(self, affine)
    }
    #[inline]
    pub unsafe fn mapPoints(
        &self,
        dst: *mut SkPoint,
        src: *const SkPoint,
        count: ::std::os::raw::c_int,
    ) {
        SkMatrix_mapPoints(self, dst, src, count)
    }
    #[inline]
    pub unsafe fn mapHomogeneousPoints(
        &self,
        dst: *mut SkPoint3,
        src: *const SkPoint3,
        count: ::std::os::raw::c_int,
    ) {
        SkMatrix_mapHomogeneousPoints(self, dst, src, count)
    }
    #[inline]
    pub unsafe fn mapXY(&self, x: SkScalar, y: SkScalar, result: *mut SkPoint) {
        SkMatrix_mapXY(self, x, y, result)
    }
    #[inline]
    pub unsafe fn mapVectors(
        &self,
        dst: *mut SkVector,
        src: *const SkVector,
        count: ::std::os::raw::c_int,
    ) {
        SkMatrix_mapVectors(self, dst, src, count)
    }
    #[inline]
    pub unsafe fn mapRect(&self, dst: *mut SkRect, src: *const SkRect) -> bool {
        SkMatrix_mapRect(self, dst, src)
    }
    #[inline]
    pub unsafe fn mapRectScaleTranslate(&self, dst: *mut SkRect, src: *const SkRect) {
        SkMatrix_mapRectScaleTranslate(self, dst, src)
    }
    #[inline]
    pub unsafe fn mapRadius(&self, radius: SkScalar) -> SkScalar {
        SkMatrix_mapRadius(self, radius)
    }
    #[inline]
    pub unsafe fn isFixedStepInX(&self) -> bool {
        SkMatrix_isFixedStepInX(self)
    }
    #[inline]
    pub unsafe fn fixedStepInX(&self, y: SkScalar) -> SkVector {
        SkMatrix_fixedStepInX(self, y)
    }
    #[inline]
    pub unsafe fn dump(&self) {
        SkMatrix_dump(self)
    }
    #[inline]
    pub unsafe fn getMinScale(&self) -> SkScalar {
        SkMatrix_getMinScale(self)
    }
    #[inline]
    pub unsafe fn getMaxScale(&self) -> SkScalar {
        SkMatrix_getMaxScale(self)
    }
    #[inline]
    pub unsafe fn getMinMaxScales(&self, scaleFactors: *mut SkScalar) -> bool {
        SkMatrix_getMinMaxScales(self, scaleFactors)
    }
    #[inline]
    pub unsafe fn decomposeScale(&self, scale: *mut SkSize, remaining: *mut SkMatrix) -> bool {
        SkMatrix_decomposeScale(self, scale, remaining)
    }
    #[inline]
    pub unsafe fn I() -> *const SkMatrix {
        SkMatrix_I()
    }
    #[inline]
    pub unsafe fn InvalidMatrix() -> *const SkMatrix {
        SkMatrix_InvalidMatrix()
    }
}
impl SkEncodedOrigin {
    pub const kDefault_SkEncodedOrigin: SkEncodedOrigin = SkEncodedOrigin::kTopLeft_SkEncodedOrigin;
}
impl SkEncodedOrigin {
    pub const kLast_SkEncodedOrigin: SkEncodedOrigin = SkEncodedOrigin::kLeftBottom_SkEncodedOrigin;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkEncodedOrigin {
    kTopLeft_SkEncodedOrigin = 1,
    kTopRight_SkEncodedOrigin = 2,
    kBottomRight_SkEncodedOrigin = 3,
    kBottomLeft_SkEncodedOrigin = 4,
    kLeftTop_SkEncodedOrigin = 5,
    kRightTop_SkEncodedOrigin = 6,
    kRightBottom_SkEncodedOrigin = 7,
    kLeftBottom_SkEncodedOrigin = 8,
}
extern "C" {
    #[link_name = "\u{1}_Z21SkAnnotateRectWithURLP8SkCanvasRK6SkRectP6SkData"]
    pub fn SkAnnotateRectWithURL(arg1: *mut SkCanvas, arg2: *const SkRect, arg3: *mut SkData);
}
extern "C" {
    #[link_name = "\u{1}_Z26SkAnnotateNamedDestinationP8SkCanvasRK7SkPointP6SkData"]
    pub fn SkAnnotateNamedDestination(arg1: *mut SkCanvas, arg2: *const SkPoint, arg3: *mut SkData);
}
extern "C" {
    #[link_name = "\u{1}_Z27SkAnnotateLinkToDestinationP8SkCanvasRK6SkRectP6SkData"]
    pub fn SkAnnotateLinkToDestination(arg1: *mut SkCanvas, arg2: *const SkRect, arg3: *mut SkData);
}
impl SkBlendMode {
    pub const kLastCoeffMode: SkBlendMode = SkBlendMode::kScreen;
}
impl SkBlendMode {
    pub const kLastSeparableMode: SkBlendMode = SkBlendMode::kMultiply;
}
impl SkBlendMode {
    pub const kLastMode: SkBlendMode = SkBlendMode::kLuminosity;
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkBlendMode {
    kClear = 0,
    kSrc = 1,
    kDst = 2,
    kSrcOver = 3,
    kDstOver = 4,
    kSrcIn = 5,
    kDstIn = 6,
    kSrcOut = 7,
    kDstOut = 8,
    kSrcATop = 9,
    kDstATop = 10,
    kXor = 11,
    kPlus = 12,
    kModulate = 13,
    kScreen = 14,
    kOverlay = 15,
    kDarken = 16,
    kLighten = 17,
    kColorDodge = 18,
    kColorBurn = 19,
    kHardLight = 20,
    kSoftLight = 21,
    kDifference = 22,
    kExclusion = 23,
    kMultiply = 24,
    kHue = 25,
    kSaturation = 26,
    kColor = 27,
    kLuminosity = 28,
}
extern "C" {
    #[link_name = "\u{1}_Z16SkBlendMode_Name11SkBlendMode"]
    pub fn SkBlendMode_Name(blendMode: SkBlendMode) -> *const ::std::os::raw::c_char;
}
impl SkClipOp {
    pub const kMax_EnumValue: SkClipOp = SkClipOp::kExtraEnumNeedInternallyPleaseIgnoreWillGoAway5;
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkClipOp {
    kDifference = 0,
    kIntersect = 1,
    kExtraEnumNeedInternallyPleaseIgnoreWillGoAway2 = 2,
    kExtraEnumNeedInternallyPleaseIgnoreWillGoAway3 = 3,
    kExtraEnumNeedInternallyPleaseIgnoreWillGoAway4 = 4,
    kExtraEnumNeedInternallyPleaseIgnoreWillGoAway5 = 5,
}
pub type SkMScalar = f32;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkVector4 {
    pub fData: [SkScalar; 4usize],
}
#[test]
fn bindgen_test_layout_SkVector4() {
    assert_eq!(
        ::core::mem::size_of::<SkVector4>(),
        16usize,
        concat!("Size of: ", stringify!(SkVector4))
    );
    assert_eq!(
        ::core::mem::align_of::<SkVector4>(),
        4usize,
        concat!("Alignment of ", stringify!(SkVector4))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkVector4>())).fData as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkVector4),
            "::",
            stringify!(fData)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkMatrix44 {
    pub fMat: [[SkMScalar; 4usize]; 4usize],
    pub fTypeMask: SkMatrix44_TypeMask,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkMatrix44_Uninitialized_Constructor {
    kUninitialized_Constructor = 0,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkMatrix44_Identity_Constructor {
    kIdentity_Constructor = 0,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkMatrix44_NaN_Constructor {
    kNaN_Constructor = 0,
}
pub type SkMatrix44_TypeMask = u8;
pub const SkMatrix44_kIdentity_Mask: SkMatrix44__bindgen_ty_1 = 0;
pub const SkMatrix44_kTranslate_Mask: SkMatrix44__bindgen_ty_1 = 1;
pub const SkMatrix44_kScale_Mask: SkMatrix44__bindgen_ty_1 = 2;
pub const SkMatrix44_kAffine_Mask: SkMatrix44__bindgen_ty_1 = 4;
pub const SkMatrix44_kPerspective_Mask: SkMatrix44__bindgen_ty_1 = 8;
pub type SkMatrix44__bindgen_ty_1 = u8;
pub const SkMatrix44_kAllPublic_Masks: ::std::os::raw::c_int = 15;
#[test]
fn bindgen_test_layout_SkMatrix44() {
    assert_eq!(
        ::core::mem::size_of::<SkMatrix44>(),
        68usize,
        concat!("Size of: ", stringify!(SkMatrix44))
    );
    assert_eq!(
        ::core::mem::align_of::<SkMatrix44>(),
        4usize,
        concat!("Alignment of ", stringify!(SkMatrix44))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkMatrix44>())).fMat as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkMatrix44),
            "::",
            stringify!(fMat)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkMatrix44>())).fTypeMask as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(SkMatrix44),
            "::",
            stringify!(fTypeMask)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix441IEv"]
    pub fn SkMatrix44_I() -> *const SkMatrix44;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix4411setIdentityEv"]
    pub fn SkMatrix44_setIdentity(this: *mut SkMatrix44);
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkMatrix4411asColMajorfEPf"]
    pub fn SkMatrix44_asColMajorf(this: *const SkMatrix44, arg1: *mut f32);
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkMatrix4411asColMajordEPd"]
    pub fn SkMatrix44_asColMajord(this: *const SkMatrix44, arg1: *mut f64);
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkMatrix4411asRowMajorfEPf"]
    pub fn SkMatrix44_asRowMajorf(this: *const SkMatrix44, arg1: *mut f32);
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkMatrix4411asRowMajordEPd"]
    pub fn SkMatrix44_asRowMajord(this: *const SkMatrix44, arg1: *mut f64);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix4412setColMajorfEPKf"]
    pub fn SkMatrix44_setColMajorf(this: *mut SkMatrix44, arg1: *const f32);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix4412setColMajordEPKd"]
    pub fn SkMatrix44_setColMajord(this: *mut SkMatrix44, arg1: *const f64);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix4412setRowMajorfEPKf"]
    pub fn SkMatrix44_setRowMajorf(this: *mut SkMatrix44, arg1: *const f32);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix4412setRowMajordEPKd"]
    pub fn SkMatrix44_setRowMajord(this: *mut SkMatrix44, arg1: *const f64);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix446set3x3Efffffffff"]
    pub fn SkMatrix44_set3x3(
        this: *mut SkMatrix44,
        m_00: SkMScalar,
        m_10: SkMScalar,
        m_20: SkMScalar,
        m_01: SkMScalar,
        m_11: SkMScalar,
        m_21: SkMScalar,
        m_02: SkMScalar,
        m_12: SkMScalar,
        m_22: SkMScalar,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix4415set3x3RowMajorfEPKf"]
    pub fn SkMatrix44_set3x3RowMajorf(this: *mut SkMatrix44, arg1: *const f32);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix446set4x4Effffffffffffffff"]
    pub fn SkMatrix44_set4x4(
        this: *mut SkMatrix44,
        m_00: SkMScalar,
        m_10: SkMScalar,
        m_20: SkMScalar,
        m_30: SkMScalar,
        m_01: SkMScalar,
        m_11: SkMScalar,
        m_21: SkMScalar,
        m_31: SkMScalar,
        m_02: SkMScalar,
        m_12: SkMScalar,
        m_22: SkMScalar,
        m_32: SkMScalar,
        m_03: SkMScalar,
        m_13: SkMScalar,
        m_23: SkMScalar,
        m_33: SkMScalar,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix4412setTranslateEfff"]
    pub fn SkMatrix44_setTranslate(
        this: *mut SkMatrix44,
        dx: SkMScalar,
        dy: SkMScalar,
        dz: SkMScalar,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix4412preTranslateEfff"]
    pub fn SkMatrix44_preTranslate(
        this: *mut SkMatrix44,
        dx: SkMScalar,
        dy: SkMScalar,
        dz: SkMScalar,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix4413postTranslateEfff"]
    pub fn SkMatrix44_postTranslate(
        this: *mut SkMatrix44,
        dx: SkMScalar,
        dy: SkMScalar,
        dz: SkMScalar,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix448setScaleEfff"]
    pub fn SkMatrix44_setScale(this: *mut SkMatrix44, sx: SkMScalar, sy: SkMScalar, sz: SkMScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix448preScaleEfff"]
    pub fn SkMatrix44_preScale(this: *mut SkMatrix44, sx: SkMScalar, sy: SkMScalar, sz: SkMScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix449postScaleEfff"]
    pub fn SkMatrix44_postScale(this: *mut SkMatrix44, sx: SkMScalar, sy: SkMScalar, sz: SkMScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix4414setRotateAboutEffff"]
    pub fn SkMatrix44_setRotateAbout(
        this: *mut SkMatrix44,
        x: SkMScalar,
        y: SkMScalar,
        z: SkMScalar,
        radians: SkMScalar,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix4418setRotateAboutUnitEffff"]
    pub fn SkMatrix44_setRotateAboutUnit(
        this: *mut SkMatrix44,
        x: SkMScalar,
        y: SkMScalar,
        z: SkMScalar,
        radians: SkMScalar,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix449setConcatERKS_S1_"]
    pub fn SkMatrix44_setConcat(this: *mut SkMatrix44, a: *const SkMatrix44, b: *const SkMatrix44);
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkMatrix446invertEPS_"]
    pub fn SkMatrix44_invert(this: *const SkMatrix44, inverse: *mut SkMatrix44) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix449transposeEv"]
    pub fn SkMatrix44_transpose(this: *mut SkMatrix44);
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkMatrix4410mapScalarsEPKfPf"]
    pub fn SkMatrix44_mapScalars(this: *const SkMatrix44, src: *const SkScalar, dst: *mut SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkMatrix444map2EPKfiPf"]
    pub fn SkMatrix44_map2(
        this: *const SkMatrix44,
        src2: *const f32,
        count: ::std::os::raw::c_int,
        dst4: *mut f32,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkMatrix444map2EPKdiPd"]
    pub fn SkMatrix44_map21(
        this: *const SkMatrix44,
        src2: *const f64,
        count: ::std::os::raw::c_int,
        dst4: *mut f64,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkMatrix4424preserves2dAxisAlignmentEf"]
    pub fn SkMatrix44_preserves2dAxisAlignment(this: *const SkMatrix44, epsilon: SkMScalar)
        -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkMatrix444dumpEv"]
    pub fn SkMatrix44_dump(this: *const SkMatrix44);
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkMatrix4411determinantEv"]
    pub fn SkMatrix44_determinant(this: *const SkMatrix44) -> f64;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix44C1ERK8SkMatrix"]
    pub fn SkMatrix44_SkMatrix44(this: *mut SkMatrix44, arg1: *const SkMatrix);
}
impl SkMatrix44 {
    #[inline]
    pub unsafe fn I() -> *const SkMatrix44 {
        SkMatrix44_I()
    }
    #[inline]
    pub unsafe fn setIdentity(&mut self) {
        SkMatrix44_setIdentity(self)
    }
    #[inline]
    pub unsafe fn asColMajorf(&self, arg1: *mut f32) {
        SkMatrix44_asColMajorf(self, arg1)
    }
    #[inline]
    pub unsafe fn asColMajord(&self, arg1: *mut f64) {
        SkMatrix44_asColMajord(self, arg1)
    }
    #[inline]
    pub unsafe fn asRowMajorf(&self, arg1: *mut f32) {
        SkMatrix44_asRowMajorf(self, arg1)
    }
    #[inline]
    pub unsafe fn asRowMajord(&self, arg1: *mut f64) {
        SkMatrix44_asRowMajord(self, arg1)
    }
    #[inline]
    pub unsafe fn setColMajorf(&mut self, arg1: *const f32) {
        SkMatrix44_setColMajorf(self, arg1)
    }
    #[inline]
    pub unsafe fn setColMajord(&mut self, arg1: *const f64) {
        SkMatrix44_setColMajord(self, arg1)
    }
    #[inline]
    pub unsafe fn setRowMajorf(&mut self, arg1: *const f32) {
        SkMatrix44_setRowMajorf(self, arg1)
    }
    #[inline]
    pub unsafe fn setRowMajord(&mut self, arg1: *const f64) {
        SkMatrix44_setRowMajord(self, arg1)
    }
    #[inline]
    pub unsafe fn set3x3(
        &mut self,
        m_00: SkMScalar,
        m_10: SkMScalar,
        m_20: SkMScalar,
        m_01: SkMScalar,
        m_11: SkMScalar,
        m_21: SkMScalar,
        m_02: SkMScalar,
        m_12: SkMScalar,
        m_22: SkMScalar,
    ) {
        SkMatrix44_set3x3(self, m_00, m_10, m_20, m_01, m_11, m_21, m_02, m_12, m_22)
    }
    #[inline]
    pub unsafe fn set3x3RowMajorf(&mut self, arg1: *const f32) {
        SkMatrix44_set3x3RowMajorf(self, arg1)
    }
    #[inline]
    pub unsafe fn set4x4(
        &mut self,
        m_00: SkMScalar,
        m_10: SkMScalar,
        m_20: SkMScalar,
        m_30: SkMScalar,
        m_01: SkMScalar,
        m_11: SkMScalar,
        m_21: SkMScalar,
        m_31: SkMScalar,
        m_02: SkMScalar,
        m_12: SkMScalar,
        m_22: SkMScalar,
        m_32: SkMScalar,
        m_03: SkMScalar,
        m_13: SkMScalar,
        m_23: SkMScalar,
        m_33: SkMScalar,
    ) {
        SkMatrix44_set4x4(
            self, m_00, m_10, m_20, m_30, m_01, m_11, m_21, m_31, m_02, m_12, m_22, m_32, m_03,
            m_13, m_23, m_33,
        )
    }
    #[inline]
    pub unsafe fn setTranslate(&mut self, dx: SkMScalar, dy: SkMScalar, dz: SkMScalar) {
        SkMatrix44_setTranslate(self, dx, dy, dz)
    }
    #[inline]
    pub unsafe fn preTranslate(&mut self, dx: SkMScalar, dy: SkMScalar, dz: SkMScalar) {
        SkMatrix44_preTranslate(self, dx, dy, dz)
    }
    #[inline]
    pub unsafe fn postTranslate(&mut self, dx: SkMScalar, dy: SkMScalar, dz: SkMScalar) {
        SkMatrix44_postTranslate(self, dx, dy, dz)
    }
    #[inline]
    pub unsafe fn setScale(&mut self, sx: SkMScalar, sy: SkMScalar, sz: SkMScalar) {
        SkMatrix44_setScale(self, sx, sy, sz)
    }
    #[inline]
    pub unsafe fn preScale(&mut self, sx: SkMScalar, sy: SkMScalar, sz: SkMScalar) {
        SkMatrix44_preScale(self, sx, sy, sz)
    }
    #[inline]
    pub unsafe fn postScale(&mut self, sx: SkMScalar, sy: SkMScalar, sz: SkMScalar) {
        SkMatrix44_postScale(self, sx, sy, sz)
    }
    #[inline]
    pub unsafe fn setRotateAbout(
        &mut self,
        x: SkMScalar,
        y: SkMScalar,
        z: SkMScalar,
        radians: SkMScalar,
    ) {
        SkMatrix44_setRotateAbout(self, x, y, z, radians)
    }
    #[inline]
    pub unsafe fn setRotateAboutUnit(
        &mut self,
        x: SkMScalar,
        y: SkMScalar,
        z: SkMScalar,
        radians: SkMScalar,
    ) {
        SkMatrix44_setRotateAboutUnit(self, x, y, z, radians)
    }
    #[inline]
    pub unsafe fn setConcat(&mut self, a: *const SkMatrix44, b: *const SkMatrix44) {
        SkMatrix44_setConcat(self, a, b)
    }
    #[inline]
    pub unsafe fn invert(&self, inverse: *mut SkMatrix44) -> bool {
        SkMatrix44_invert(self, inverse)
    }
    #[inline]
    pub unsafe fn transpose(&mut self) {
        SkMatrix44_transpose(self)
    }
    #[inline]
    pub unsafe fn mapScalars(&self, src: *const SkScalar, dst: *mut SkScalar) {
        SkMatrix44_mapScalars(self, src, dst)
    }
    #[inline]
    pub unsafe fn map2(&self, src2: *const f32, count: ::std::os::raw::c_int, dst4: *mut f32) {
        SkMatrix44_map2(self, src2, count, dst4)
    }
    #[inline]
    pub unsafe fn map21(&self, src2: *const f64, count: ::std::os::raw::c_int, dst4: *mut f64) {
        SkMatrix44_map21(self, src2, count, dst4)
    }
    #[inline]
    pub unsafe fn preserves2dAxisAlignment(&self, epsilon: SkMScalar) -> bool {
        SkMatrix44_preserves2dAxisAlignment(self, epsilon)
    }
    #[inline]
    pub unsafe fn dump(&self) {
        SkMatrix44_dump(self)
    }
    #[inline]
    pub unsafe fn determinant(&self) -> f64 {
        SkMatrix44_determinant(self)
    }
    #[inline]
    pub unsafe fn new(arg1: *const SkMatrix) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkMatrix44_SkMatrix44(&mut __bindgen_tmp, arg1);
        __bindgen_tmp
    }
}
pub type FILE = _IO_FILE;
pub type va_list = __builtin_va_list;
pub type _IO_lock_t = ::std::os::raw::c_void;
#[repr(C)]
#[derive(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!(
        ::core::mem::size_of::<_IO_marker>(),
        24usize,
        concat!("Size of: ", stringify!(_IO_marker))
    );
    assert_eq!(
        ::core::mem::align_of::<_IO_marker>(),
        8usize,
        concat!("Alignment of ", stringify!(_IO_marker))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_marker>()))._next as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_marker),
            "::",
            stringify!(_next)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_marker>()))._sbuf as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_marker),
            "::",
            stringify!(_sbuf)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_marker>()))._pos as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_marker),
            "::",
            stringify!(_pos)
        )
    );
}
#[repr(C)]
#[derive(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!(
        ::core::mem::size_of::<_IO_FILE>(),
        216usize,
        concat!("Size of: ", stringify!(_IO_FILE))
    );
    assert_eq!(
        ::core::mem::align_of::<_IO_FILE>(),
        8usize,
        concat!("Alignment of ", stringify!(_IO_FILE))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._flags as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::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 { &(*(::core::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 { &(*(::core::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 { &(*(::core::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 { &(*(::core::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 { &(*(::core::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 { &(*(::core::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 { &(*(::core::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 { &(*(::core::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 { &(*(::core::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 { &(*(::core::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 { &(*(::core::ptr::null::<_IO_FILE>()))._markers as *const _ as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_markers)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._chain as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_chain)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._fileno as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_fileno)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._flags2 as *const _ as usize },
        116usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_flags2)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._old_offset as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_old_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._cur_column as *const _ as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_cur_column)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._vtable_offset as *const _ as usize },
        130usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_vtable_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._shortbuf as *const _ as usize },
        131usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_shortbuf)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._lock as *const _ as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_lock)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._offset as *const _ as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>())).__pad1 as *const _ as usize },
        152usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(__pad1)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>())).__pad2 as *const _ as usize },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(__pad2)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>())).__pad3 as *const _ as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(__pad3)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>())).__pad4 as *const _ as usize },
        176usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(__pad4)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>())).__pad5 as *const _ as usize },
        184usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(__pad5)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._mode as *const _ as usize },
        192usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_mode)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<_IO_FILE>()))._unused2 as *const _ as usize },
        196usize,
        concat!(
            "Offset of field: ",
            stringify!(_IO_FILE),
            "::",
            stringify!(_unused2)
        )
    );
}
#[repr(C)]
pub struct SkRefCntBase__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
pub struct SkRefCntBase {
    pub vtable_: *const SkRefCntBase__bindgen_vtable,
    pub fRefCnt: u32,
}
#[test]
fn bindgen_test_layout_SkRefCntBase() {
    assert_eq!(
        ::core::mem::size_of::<SkRefCntBase>(),
        16usize,
        concat!("Size of: ", stringify!(SkRefCntBase))
    );
    assert_eq!(
        ::core::mem::align_of::<SkRefCntBase>(),
        8usize,
        concat!("Alignment of ", stringify!(SkRefCntBase))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRefCntBase>())).fRefCnt as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRefCntBase),
            "::",
            stringify!(fRefCnt)
        )
    );
}
#[repr(C)]
pub struct SkRefCnt {
    pub _base: SkRefCntBase,
}
#[test]
fn bindgen_test_layout_SkRefCnt() {
    assert_eq!(
        ::core::mem::size_of::<SkRefCnt>(),
        16usize,
        concat!("Size of: ", stringify!(SkRefCnt))
    );
    assert_eq!(
        ::core::mem::align_of::<SkRefCnt>(),
        8usize,
        concat!("Alignment of ", stringify!(SkRefCnt))
    );
}
#[repr(C)]
pub struct SkNVRefCnt {
    pub fRefCnt: u32,
}
#[repr(C)]
pub struct sk_sp<T> {
    pub fPtr: *mut T,
    pub _phantom_0: ::core::marker::PhantomData<::core::cell::UnsafeCell<T>>,
}
pub type sk_sp_element_type<T> = T;
#[repr(C)]
pub struct SkOnce {
    pub fState: u8,
}
#[repr(u8)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkOnce_State {
    NotStarted = 0,
    Claimed = 1,
    Done = 2,
}
#[test]
fn bindgen_test_layout_SkOnce() {
    assert_eq!(
        ::core::mem::size_of::<SkOnce>(),
        1usize,
        concat!("Size of: ", stringify!(SkOnce))
    );
    assert_eq!(
        ::core::mem::align_of::<SkOnce>(),
        1usize,
        concat!("Alignment of ", stringify!(SkOnce))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkOnce>())).fState as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkOnce),
            "::",
            stringify!(fState)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct skcms_Matrix3x3 {
    pub vals: [[f32; 3usize]; 3usize],
}
#[test]
fn bindgen_test_layout_skcms_Matrix3x3() {
    assert_eq!(
        ::core::mem::size_of::<skcms_Matrix3x3>(),
        36usize,
        concat!("Size of: ", stringify!(skcms_Matrix3x3))
    );
    assert_eq!(
        ::core::mem::align_of::<skcms_Matrix3x3>(),
        4usize,
        concat!("Alignment of ", stringify!(skcms_Matrix3x3))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_Matrix3x3>())).vals as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_Matrix3x3),
            "::",
            stringify!(vals)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct skcms_Matrix3x4 {
    pub vals: [[f32; 4usize]; 3usize],
}
#[test]
fn bindgen_test_layout_skcms_Matrix3x4() {
    assert_eq!(
        ::core::mem::size_of::<skcms_Matrix3x4>(),
        48usize,
        concat!("Size of: ", stringify!(skcms_Matrix3x4))
    );
    assert_eq!(
        ::core::mem::align_of::<skcms_Matrix3x4>(),
        4usize,
        concat!("Alignment of ", stringify!(skcms_Matrix3x4))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_Matrix3x4>())).vals as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_Matrix3x4),
            "::",
            stringify!(vals)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct skcms_TransferFunction {
    pub g: f32,
    pub a: f32,
    pub b: f32,
    pub c: f32,
    pub d: f32,
    pub e: f32,
    pub f: f32,
}
#[test]
fn bindgen_test_layout_skcms_TransferFunction() {
    assert_eq!(
        ::core::mem::size_of::<skcms_TransferFunction>(),
        28usize,
        concat!("Size of: ", stringify!(skcms_TransferFunction))
    );
    assert_eq!(
        ::core::mem::align_of::<skcms_TransferFunction>(),
        4usize,
        concat!("Alignment of ", stringify!(skcms_TransferFunction))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_TransferFunction>())).g as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_TransferFunction),
            "::",
            stringify!(g)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_TransferFunction>())).a as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_TransferFunction),
            "::",
            stringify!(a)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_TransferFunction>())).b as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_TransferFunction),
            "::",
            stringify!(b)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_TransferFunction>())).c as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_TransferFunction),
            "::",
            stringify!(c)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_TransferFunction>())).d as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_TransferFunction),
            "::",
            stringify!(d)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_TransferFunction>())).e as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_TransferFunction),
            "::",
            stringify!(e)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_TransferFunction>())).f as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_TransferFunction),
            "::",
            stringify!(f)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union skcms_Curve {
    pub __bindgen_anon_1: skcms_Curve__bindgen_ty_1,
    pub __bindgen_anon_2: skcms_Curve__bindgen_ty_2,
    _bindgen_union_align: [u64; 4usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct skcms_Curve__bindgen_ty_1 {
    pub alias_of_table_entries: u32,
    pub parametric: skcms_TransferFunction,
}
#[test]
fn bindgen_test_layout_skcms_Curve__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<skcms_Curve__bindgen_ty_1>(),
        32usize,
        concat!("Size of: ", stringify!(skcms_Curve__bindgen_ty_1))
    );
    assert_eq!(
        ::core::mem::align_of::<skcms_Curve__bindgen_ty_1>(),
        4usize,
        concat!("Alignment of ", stringify!(skcms_Curve__bindgen_ty_1))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<skcms_Curve__bindgen_ty_1>())).alias_of_table_entries
                as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_Curve__bindgen_ty_1),
            "::",
            stringify!(alias_of_table_entries)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<skcms_Curve__bindgen_ty_1>())).parametric as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_Curve__bindgen_ty_1),
            "::",
            stringify!(parametric)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct skcms_Curve__bindgen_ty_2 {
    pub table_entries: u32,
    pub table_8: *const u8,
    pub table_16: *const u8,
}
#[test]
fn bindgen_test_layout_skcms_Curve__bindgen_ty_2() {
    assert_eq!(
        ::core::mem::size_of::<skcms_Curve__bindgen_ty_2>(),
        24usize,
        concat!("Size of: ", stringify!(skcms_Curve__bindgen_ty_2))
    );
    assert_eq!(
        ::core::mem::align_of::<skcms_Curve__bindgen_ty_2>(),
        8usize,
        concat!("Alignment of ", stringify!(skcms_Curve__bindgen_ty_2))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<skcms_Curve__bindgen_ty_2>())).table_entries as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_Curve__bindgen_ty_2),
            "::",
            stringify!(table_entries)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<skcms_Curve__bindgen_ty_2>())).table_8 as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_Curve__bindgen_ty_2),
            "::",
            stringify!(table_8)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<skcms_Curve__bindgen_ty_2>())).table_16 as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_Curve__bindgen_ty_2),
            "::",
            stringify!(table_16)
        )
    );
}
#[test]
fn bindgen_test_layout_skcms_Curve() {
    assert_eq!(
        ::core::mem::size_of::<skcms_Curve>(),
        32usize,
        concat!("Size of: ", stringify!(skcms_Curve))
    );
    assert_eq!(
        ::core::mem::align_of::<skcms_Curve>(),
        8usize,
        concat!("Alignment of ", stringify!(skcms_Curve))
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct skcms_A2B {
    pub input_channels: u32,
    pub input_curves: [skcms_Curve; 4usize],
    pub grid_points: [u8; 4usize],
    pub grid_8: *const u8,
    pub grid_16: *const u8,
    pub matrix_channels: u32,
    pub matrix_curves: [skcms_Curve; 3usize],
    pub matrix: skcms_Matrix3x4,
    pub output_channels: u32,
    pub output_curves: [skcms_Curve; 3usize],
}
#[test]
fn bindgen_test_layout_skcms_A2B() {
    assert_eq!(
        ::core::mem::size_of::<skcms_A2B>(),
        416usize,
        concat!("Size of: ", stringify!(skcms_A2B))
    );
    assert_eq!(
        ::core::mem::align_of::<skcms_A2B>(),
        8usize,
        concat!("Alignment of ", stringify!(skcms_A2B))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_A2B>())).input_channels as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_A2B),
            "::",
            stringify!(input_channels)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_A2B>())).input_curves as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_A2B),
            "::",
            stringify!(input_curves)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_A2B>())).grid_points as *const _ as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_A2B),
            "::",
            stringify!(grid_points)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_A2B>())).grid_8 as *const _ as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_A2B),
            "::",
            stringify!(grid_8)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_A2B>())).grid_16 as *const _ as usize },
        152usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_A2B),
            "::",
            stringify!(grid_16)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_A2B>())).matrix_channels as *const _ as usize },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_A2B),
            "::",
            stringify!(matrix_channels)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_A2B>())).matrix_curves as *const _ as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_A2B),
            "::",
            stringify!(matrix_curves)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_A2B>())).matrix as *const _ as usize },
        264usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_A2B),
            "::",
            stringify!(matrix)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_A2B>())).output_channels as *const _ as usize },
        312usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_A2B),
            "::",
            stringify!(output_channels)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_A2B>())).output_curves as *const _ as usize },
        320usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_A2B),
            "::",
            stringify!(output_curves)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct skcms_ICCProfile {
    pub buffer: *const u8,
    pub size: u32,
    pub data_color_space: u32,
    pub pcs: u32,
    pub tag_count: u32,
    pub has_trc: bool,
    pub trc: [skcms_Curve; 3usize],
    pub has_toXYZD50: bool,
    pub toXYZD50: skcms_Matrix3x3,
    pub has_A2B: bool,
    pub A2B: skcms_A2B,
}
#[test]
fn bindgen_test_layout_skcms_ICCProfile() {
    assert_eq!(
        ::core::mem::size_of::<skcms_ICCProfile>(),
        592usize,
        concat!("Size of: ", stringify!(skcms_ICCProfile))
    );
    assert_eq!(
        ::core::mem::align_of::<skcms_ICCProfile>(),
        8usize,
        concat!("Alignment of ", stringify!(skcms_ICCProfile))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_ICCProfile>())).buffer as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_ICCProfile),
            "::",
            stringify!(buffer)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_ICCProfile>())).size as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_ICCProfile),
            "::",
            stringify!(size)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<skcms_ICCProfile>())).data_color_space as *const _ as usize
        },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_ICCProfile),
            "::",
            stringify!(data_color_space)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_ICCProfile>())).pcs as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_ICCProfile),
            "::",
            stringify!(pcs)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_ICCProfile>())).tag_count as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_ICCProfile),
            "::",
            stringify!(tag_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_ICCProfile>())).has_trc as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_ICCProfile),
            "::",
            stringify!(has_trc)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_ICCProfile>())).trc as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_ICCProfile),
            "::",
            stringify!(trc)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_ICCProfile>())).has_toXYZD50 as *const _ as usize },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_ICCProfile),
            "::",
            stringify!(has_toXYZD50)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_ICCProfile>())).toXYZD50 as *const _ as usize },
        132usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_ICCProfile),
            "::",
            stringify!(toXYZD50)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_ICCProfile>())).has_A2B as *const _ as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_ICCProfile),
            "::",
            stringify!(has_A2B)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<skcms_ICCProfile>())).A2B as *const _ as usize },
        176usize,
        concat!(
            "Offset of field: ",
            stringify!(skcms_ICCProfile),
            "::",
            stringify!(A2B)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkColorSpacePrimaries {
    pub fRX: f32,
    pub fRY: f32,
    pub fGX: f32,
    pub fGY: f32,
    pub fBX: f32,
    pub fBY: f32,
    pub fWX: f32,
    pub fWY: f32,
}
#[test]
fn bindgen_test_layout_SkColorSpacePrimaries() {
    assert_eq!(
        ::core::mem::size_of::<SkColorSpacePrimaries>(),
        32usize,
        concat!("Size of: ", stringify!(SkColorSpacePrimaries))
    );
    assert_eq!(
        ::core::mem::align_of::<SkColorSpacePrimaries>(),
        4usize,
        concat!("Alignment of ", stringify!(SkColorSpacePrimaries))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkColorSpacePrimaries>())).fRX as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkColorSpacePrimaries),
            "::",
            stringify!(fRX)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkColorSpacePrimaries>())).fRY as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkColorSpacePrimaries),
            "::",
            stringify!(fRY)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkColorSpacePrimaries>())).fGX as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkColorSpacePrimaries),
            "::",
            stringify!(fGX)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkColorSpacePrimaries>())).fGY as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(SkColorSpacePrimaries),
            "::",
            stringify!(fGY)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkColorSpacePrimaries>())).fBX as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkColorSpacePrimaries),
            "::",
            stringify!(fBX)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkColorSpacePrimaries>())).fBY as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(SkColorSpacePrimaries),
            "::",
            stringify!(fBY)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkColorSpacePrimaries>())).fWX as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkColorSpacePrimaries),
            "::",
            stringify!(fWX)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkColorSpacePrimaries>())).fWY as *const _ as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(SkColorSpacePrimaries),
            "::",
            stringify!(fWY)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK21SkColorSpacePrimaries8toXYZD50EP15skcms_Matrix3x3"]
    pub fn SkColorSpacePrimaries_toXYZD50(
        this: *const SkColorSpacePrimaries,
        toXYZD50: *mut skcms_Matrix3x3,
    ) -> bool;
}
impl SkColorSpacePrimaries {
    #[inline]
    pub unsafe fn toXYZD50(&self, toXYZD50: *mut skcms_Matrix3x3) -> bool {
        SkColorSpacePrimaries_toXYZD50(self, toXYZD50)
    }
}
#[repr(C)]
pub struct SkColorSpace {
    pub _base: SkNVRefCnt,
    pub fTransferFnHash: u32,
    pub fToXYZD50Hash: u32,
    pub fTransferFn: [f32; 7usize],
    pub fToXYZD50_3x3: [f32; 9usize],
    pub fInvTransferFn: [f32; 7usize],
    pub fFromXYZD50_3x3: [f32; 9usize],
    pub fLazyDstFieldsOnce: SkOnce,
}
#[test]
fn bindgen_test_layout_SkColorSpace() {
    assert_eq!(
        ::core::mem::size_of::<SkColorSpace>(),
        144usize,
        concat!("Size of: ", stringify!(SkColorSpace))
    );
    assert_eq!(
        ::core::mem::align_of::<SkColorSpace>(),
        4usize,
        concat!("Alignment of ", stringify!(SkColorSpace))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkColorSpace>())).fTransferFnHash as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkColorSpace),
            "::",
            stringify!(fTransferFnHash)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkColorSpace>())).fToXYZD50Hash as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkColorSpace),
            "::",
            stringify!(fToXYZD50Hash)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkColorSpace>())).fTransferFn as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(SkColorSpace),
            "::",
            stringify!(fTransferFn)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkColorSpace>())).fToXYZD50_3x3 as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(SkColorSpace),
            "::",
            stringify!(fToXYZD50_3x3)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkColorSpace>())).fInvTransferFn as *const _ as usize },
        76usize,
        concat!(
            "Offset of field: ",
            stringify!(SkColorSpace),
            "::",
            stringify!(fInvTransferFn)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkColorSpace>())).fFromXYZD50_3x3 as *const _ as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(SkColorSpace),
            "::",
            stringify!(fFromXYZD50_3x3)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkColorSpace>())).fLazyDstFieldsOnce as *const _ as usize
        },
        140usize,
        concat!(
            "Offset of field: ",
            stringify!(SkColorSpace),
            "::",
            stringify!(fLazyDstFieldsOnce)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN12SkColorSpace8MakeSRGBEv"]
    pub fn SkColorSpace_MakeSRGB() -> sk_sp<SkColorSpace>;
}
extern "C" {
    #[link_name = "\u{1}_ZN12SkColorSpace14MakeSRGBLinearEv"]
    pub fn SkColorSpace_MakeSRGBLinear() -> sk_sp<SkColorSpace>;
}
extern "C" {
    #[link_name = "\u{1}_ZN12SkColorSpace7MakeRGBERK22skcms_TransferFunctionRK15skcms_Matrix3x3"]
    pub fn SkColorSpace_MakeRGB(
        transferFn: *const skcms_TransferFunction,
        toXYZ: *const skcms_Matrix3x3,
    ) -> sk_sp<SkColorSpace>;
}
extern "C" {
    #[link_name = "\u{1}_ZN12SkColorSpace4MakeERK16skcms_ICCProfile"]
    pub fn SkColorSpace_Make(arg1: *const skcms_ICCProfile) -> sk_sp<SkColorSpace>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkColorSpace9toProfileEP16skcms_ICCProfile"]
    pub fn SkColorSpace_toProfile(this: *const SkColorSpace, arg1: *mut skcms_ICCProfile);
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkColorSpace16gammaCloseToSRGBEv"]
    pub fn SkColorSpace_gammaCloseToSRGB(this: *const SkColorSpace) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkColorSpace13gammaIsLinearEv"]
    pub fn SkColorSpace_gammaIsLinear(this: *const SkColorSpace) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkColorSpace21isNumericalTransferFnEP22skcms_TransferFunction"]
    pub fn SkColorSpace_isNumericalTransferFn(
        this: *const SkColorSpace,
        fn_: *mut skcms_TransferFunction,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkColorSpace8toXYZD50EP10SkMatrix44"]
    pub fn SkColorSpace_toXYZD50(this: *const SkColorSpace, toXYZD50: *mut SkMatrix44) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkColorSpace8toXYZD50EP15skcms_Matrix3x3"]
    pub fn SkColorSpace_toXYZD501(
        this: *const SkColorSpace,
        toXYZD50: *mut skcms_Matrix3x3,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkColorSpace15makeLinearGammaEv"]
    pub fn SkColorSpace_makeLinearGamma(this: *const SkColorSpace) -> sk_sp<SkColorSpace>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkColorSpace13makeSRGBGammaEv"]
    pub fn SkColorSpace_makeSRGBGamma(this: *const SkColorSpace) -> sk_sp<SkColorSpace>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkColorSpace13makeColorSpinEv"]
    pub fn SkColorSpace_makeColorSpin(this: *const SkColorSpace) -> sk_sp<SkColorSpace>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkColorSpace6isSRGBEv"]
    pub fn SkColorSpace_isSRGB(this: *const SkColorSpace) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkColorSpace9serializeEv"]
    pub fn SkColorSpace_serialize(this: *const SkColorSpace) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkColorSpace13writeToMemoryEPv"]
    pub fn SkColorSpace_writeToMemory(
        this: *const SkColorSpace,
        memory: *mut ::std::os::raw::c_void,
    ) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZN12SkColorSpace11DeserializeEPKvm"]
    pub fn SkColorSpace_Deserialize(
        data: *const ::std::os::raw::c_void,
        length: usize,
    ) -> sk_sp<SkColorSpace>;
}
extern "C" {
    #[link_name = "\u{1}_ZN12SkColorSpace6EqualsEPKS_S1_"]
    pub fn SkColorSpace_Equals(arg1: *const SkColorSpace, arg2: *const SkColorSpace) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkColorSpace10transferFnEPf"]
    pub fn SkColorSpace_transferFn(this: *const SkColorSpace, gabcdef: *mut f32);
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkColorSpace13invTransferFnEPf"]
    pub fn SkColorSpace_invTransferFn(this: *const SkColorSpace, gabcdef: *mut f32);
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkColorSpace16gamutTransformToEPKS_Pf"]
    pub fn SkColorSpace_gamutTransformTo(
        this: *const SkColorSpace,
        dst: *const SkColorSpace,
        src_to_dst_row_major: *mut f32,
    );
}
impl SkColorSpace {
    #[inline]
    pub unsafe fn MakeSRGB() -> sk_sp<SkColorSpace> {
        SkColorSpace_MakeSRGB()
    }
    #[inline]
    pub unsafe fn MakeSRGBLinear() -> sk_sp<SkColorSpace> {
        SkColorSpace_MakeSRGBLinear()
    }
    #[inline]
    pub unsafe fn MakeRGB(
        transferFn: *const skcms_TransferFunction,
        toXYZ: *const skcms_Matrix3x3,
    ) -> sk_sp<SkColorSpace> {
        SkColorSpace_MakeRGB(transferFn, toXYZ)
    }
    #[inline]
    pub unsafe fn Make(arg1: *const skcms_ICCProfile) -> sk_sp<SkColorSpace> {
        SkColorSpace_Make(arg1)
    }
    #[inline]
    pub unsafe fn toProfile(&self, arg1: *mut skcms_ICCProfile) {
        SkColorSpace_toProfile(self, arg1)
    }
    #[inline]
    pub unsafe fn gammaCloseToSRGB(&self) -> bool {
        SkColorSpace_gammaCloseToSRGB(self)
    }
    #[inline]
    pub unsafe fn gammaIsLinear(&self) -> bool {
        SkColorSpace_gammaIsLinear(self)
    }
    #[inline]
    pub unsafe fn isNumericalTransferFn(&self, fn_: *mut skcms_TransferFunction) -> bool {
        SkColorSpace_isNumericalTransferFn(self, fn_)
    }
    #[inline]
    pub unsafe fn toXYZD50(&self, toXYZD50: *mut SkMatrix44) -> bool {
        SkColorSpace_toXYZD50(self, toXYZD50)
    }
    #[inline]
    pub unsafe fn toXYZD501(&self, toXYZD50: *mut skcms_Matrix3x3) -> bool {
        SkColorSpace_toXYZD501(self, toXYZD50)
    }
    #[inline]
    pub unsafe fn makeLinearGamma(&self) -> sk_sp<SkColorSpace> {
        SkColorSpace_makeLinearGamma(self)
    }
    #[inline]
    pub unsafe fn makeSRGBGamma(&self) -> sk_sp<SkColorSpace> {
        SkColorSpace_makeSRGBGamma(self)
    }
    #[inline]
    pub unsafe fn makeColorSpin(&self) -> sk_sp<SkColorSpace> {
        SkColorSpace_makeColorSpin(self)
    }
    #[inline]
    pub unsafe fn isSRGB(&self) -> bool {
        SkColorSpace_isSRGB(self)
    }
    #[inline]
    pub unsafe fn serialize(&self) -> sk_sp<SkData> {
        SkColorSpace_serialize(self)
    }
    #[inline]
    pub unsafe fn writeToMemory(&self, memory: *mut ::std::os::raw::c_void) -> usize {
        SkColorSpace_writeToMemory(self, memory)
    }
    #[inline]
    pub unsafe fn Deserialize(
        data: *const ::std::os::raw::c_void,
        length: usize,
    ) -> sk_sp<SkColorSpace> {
        SkColorSpace_Deserialize(data, length)
    }
    #[inline]
    pub unsafe fn Equals(arg1: *const SkColorSpace, arg2: *const SkColorSpace) -> bool {
        SkColorSpace_Equals(arg1, arg2)
    }
    #[inline]
    pub unsafe fn transferFn(&self, gabcdef: *mut f32) {
        SkColorSpace_transferFn(self, gabcdef)
    }
    #[inline]
    pub unsafe fn invTransferFn(&self, gabcdef: *mut f32) {
        SkColorSpace_invTransferFn(self, gabcdef)
    }
    #[inline]
    pub unsafe fn gamutTransformTo(
        &self,
        dst: *const SkColorSpace,
        src_to_dst_row_major: *mut f32,
    ) {
        SkColorSpace_gamutTransformTo(self, dst, src_to_dst_row_major)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkReadBuffer {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkWriteBuffer {
    _unused: [u8; 0],
}
impl SkAlphaType {
    pub const kLastEnum_SkAlphaType: SkAlphaType = SkAlphaType::kUnpremul_SkAlphaType;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkAlphaType {
    kUnknown_SkAlphaType = 0,
    kOpaque_SkAlphaType = 1,
    kPremul_SkAlphaType = 2,
    kUnpremul_SkAlphaType = 3,
}
impl SkColorType {
    pub const kLastEnum_SkColorType: SkColorType = SkColorType::kRGBA_F32_SkColorType;
}
impl SkColorType {
    pub const kN32_SkColorType: SkColorType = SkColorType::kBGRA_8888_SkColorType;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkColorType {
    kUnknown_SkColorType = 0,
    kAlpha_8_SkColorType = 1,
    kRGB_565_SkColorType = 2,
    kARGB_4444_SkColorType = 3,
    kRGBA_8888_SkColorType = 4,
    kRGB_888x_SkColorType = 5,
    kBGRA_8888_SkColorType = 6,
    kRGBA_1010102_SkColorType = 7,
    kRGB_101010x_SkColorType = 8,
    kGray_8_SkColorType = 9,
    kRGBA_F16Norm_SkColorType = 10,
    kRGBA_F16_SkColorType = 11,
    kRGBA_F32_SkColorType = 12,
}
extern "C" {
    #[link_name = "\u{1}_Z24SkColorTypeBytesPerPixel11SkColorType"]
    pub fn SkColorTypeBytesPerPixel(ct: SkColorType) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_Z25SkColorTypeIsAlwaysOpaque11SkColorType"]
    pub fn SkColorTypeIsAlwaysOpaque(ct: SkColorType) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_Z28SkColorTypeValidateAlphaType11SkColorType11SkAlphaTypePS0_"]
    pub fn SkColorTypeValidateAlphaType(
        colorType: SkColorType,
        alphaType: SkAlphaType,
        canonical: *mut SkAlphaType,
    ) -> bool;
}
impl SkYUVColorSpace {
    pub const kLastEnum_SkYUVColorSpace: SkYUVColorSpace =
        SkYUVColorSpace::kIdentity_SkYUVColorSpace;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkYUVColorSpace {
    kJPEG_SkYUVColorSpace = 0,
    kRec601_SkYUVColorSpace = 1,
    kRec709_SkYUVColorSpace = 2,
    kIdentity_SkYUVColorSpace = 3,
}
#[repr(C)]
pub struct SkImageInfo {
    pub fColorSpace: sk_sp<SkColorSpace>,
    pub fDimensions: SkISize,
    pub fColorType: SkColorType,
    pub fAlphaType: SkAlphaType,
}
#[test]
fn bindgen_test_layout_SkImageInfo() {
    assert_eq!(
        ::core::mem::size_of::<SkImageInfo>(),
        24usize,
        concat!("Size of: ", stringify!(SkImageInfo))
    );
    assert_eq!(
        ::core::mem::align_of::<SkImageInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(SkImageInfo))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkImageInfo>())).fColorSpace as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImageInfo),
            "::",
            stringify!(fColorSpace)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkImageInfo>())).fDimensions as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImageInfo),
            "::",
            stringify!(fDimensions)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkImageInfo>())).fColorType as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImageInfo),
            "::",
            stringify!(fColorType)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkImageInfo>())).fAlphaType as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImageInfo),
            "::",
            stringify!(fAlphaType)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkImageInfo7MakeS32Eii11SkAlphaType"]
    pub fn SkImageInfo_MakeS32(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        at: SkAlphaType,
    ) -> SkImageInfo;
}
extern "C" {
    #[link_name = "\u{1}_ZNK11SkImageInfo13bytesPerPixelEv"]
    pub fn SkImageInfo_bytesPerPixel(this: *const SkImageInfo) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZNK11SkImageInfo13shiftPerPixelEv"]
    pub fn SkImageInfo_shiftPerPixel(this: *const SkImageInfo) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZNK11SkImageInfo13computeOffsetEiim"]
    pub fn SkImageInfo_computeOffset(
        this: *const SkImageInfo,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
        rowBytes: usize,
    ) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZNK11SkImageInfo15computeByteSizeEm"]
    pub fn SkImageInfo_computeByteSize(this: *const SkImageInfo, rowBytes: usize) -> usize;
}
impl SkImageInfo {
    #[inline]
    pub unsafe fn MakeS32(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        at: SkAlphaType,
    ) -> SkImageInfo {
        SkImageInfo_MakeS32(width, height, at)
    }
    #[inline]
    pub unsafe fn bytesPerPixel(&self) -> ::std::os::raw::c_int {
        SkImageInfo_bytesPerPixel(self)
    }
    #[inline]
    pub unsafe fn shiftPerPixel(&self) -> ::std::os::raw::c_int {
        SkImageInfo_shiftPerPixel(self)
    }
    #[inline]
    pub unsafe fn computeOffset(
        &self,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
        rowBytes: usize,
    ) -> usize {
        SkImageInfo_computeOffset(self, x, y, rowBytes)
    }
    #[inline]
    pub unsafe fn computeByteSize(&self, rowBytes: usize) -> usize {
        SkImageInfo_computeByteSize(self, rowBytes)
    }
}
pub type SkColor = u32;
pub const SK_ColorTRANSPARENT: SkColor = 0;
pub const SK_ColorBLACK: SkColor = 4278190080;
pub const SK_ColorDKGRAY: SkColor = 4282664004;
pub const SK_ColorGRAY: SkColor = 4287137928;
pub const SK_ColorLTGRAY: SkColor = 4291611852;
pub const SK_ColorWHITE: SkColor = 4294967295;
pub const SK_ColorRED: SkColor = 4294901760;
pub const SK_ColorGREEN: SkColor = 4278255360;
pub const SK_ColorBLUE: SkColor = 4278190335;
pub const SK_ColorYELLOW: SkColor = 4294967040;
pub const SK_ColorCYAN: SkColor = 4278255615;
pub const SK_ColorMAGENTA: SkColor = 4294902015;
extern "C" {
    #[link_name = "\u{1}_Z10SkRGBToHSVjjjPf"]
    pub fn SkRGBToHSV(red: U8CPU, green: U8CPU, blue: U8CPU, hsv: *mut SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_Z12SkHSVToColorjPKf"]
    pub fn SkHSVToColor(alpha: U8CPU, hsv: *const SkScalar) -> SkColor;
}
pub type SkPMColor = u32;
extern "C" {
    #[link_name = "\u{1}_Z17SkPreMultiplyARGBjjjj"]
    pub fn SkPreMultiplyARGB(a: U8CPU, r: U8CPU, g: U8CPU, b: U8CPU) -> SkPMColor;
}
extern "C" {
    #[link_name = "\u{1}_Z18SkPreMultiplyColorj"]
    pub fn SkPreMultiplyColor(c: SkColor) -> SkPMColor;
}
extern "C" {
    #[link_name = "\u{1}FromColor"]
    pub fn SkRGBA4f_FromColor(color: SkColor) -> u8;
}
extern "C" {
    #[link_name = "\u{1}toSkColor"]
    pub fn SkRGBA4f_toSkColor(this: *const u8) -> SkColor;
}
extern "C" {
    #[link_name = "\u{1}FromPMColor"]
    pub fn SkRGBA4f_FromPMColor(arg1: SkPMColor) -> u8;
}
extern "C" {
    #[link_name = "\u{1}toBytes_RGBA"]
    pub fn SkRGBA4f_toBytes_RGBA(this: *const u8) -> u32;
}
extern "C" {
    #[link_name = "\u{1}FromBytes_RGBA"]
    pub fn SkRGBA4f_FromBytes_RGBA(color: u32) -> u8;
}
pub type SkColor4f = [u32; 4usize];
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub struct SkDeque {
    pub _bindgen_opaque_blob: [u64; 7usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkDeque_Block {
    _unused: [u8; 0],
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub struct SkDeque_Iter {
    pub _bindgen_opaque_blob: [u64; 3usize],
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkDeque_Iter_IterStart {
    kFront_IterStart = 0,
    kBack_IterStart = 1,
}
#[test]
fn bindgen_test_layout_SkDeque_Iter() {
    assert_eq!(
        ::core::mem::size_of::<SkDeque_Iter>(),
        24usize,
        concat!("Size of: ", stringify!(SkDeque_Iter))
    );
    assert_eq!(
        ::core::mem::align_of::<SkDeque_Iter>(),
        8usize,
        concat!("Alignment of ", stringify!(SkDeque_Iter))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkDeque4Iter4nextEv"]
    pub fn SkDeque_Iter_next(this: *mut SkDeque_Iter) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkDeque4Iter4prevEv"]
    pub fn SkDeque_Iter_prev(this: *mut SkDeque_Iter) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkDeque4Iter5resetERKS_NS0_9IterStartE"]
    pub fn SkDeque_Iter_reset(
        this: *mut SkDeque_Iter,
        d: *const SkDeque,
        startLoc: SkDeque_Iter_IterStart,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkDeque4IterC1Ev"]
    pub fn SkDeque_Iter_Iter(this: *mut SkDeque_Iter);
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkDeque4IterC1ERKS_NS0_9IterStartE"]
    pub fn SkDeque_Iter_Iter1(
        this: *mut SkDeque_Iter,
        d: *const SkDeque,
        startLoc: SkDeque_Iter_IterStart,
    );
}
impl SkDeque_Iter {
    #[inline]
    pub unsafe fn next(&mut self) -> *mut ::std::os::raw::c_void {
        SkDeque_Iter_next(self)
    }
    #[inline]
    pub unsafe fn prev(&mut self) -> *mut ::std::os::raw::c_void {
        SkDeque_Iter_prev(self)
    }
    #[inline]
    pub unsafe fn reset(&mut self, d: *const SkDeque, startLoc: SkDeque_Iter_IterStart) {
        SkDeque_Iter_reset(self, d, startLoc)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkDeque_Iter_Iter(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(d: *const SkDeque, startLoc: SkDeque_Iter_IterStart) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkDeque_Iter_Iter1(&mut __bindgen_tmp, d, startLoc);
        __bindgen_tmp
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkDeque_F2BIter {
    pub _base: SkDeque_Iter,
}
pub type SkDeque_F2BIter_INHERITED = SkDeque_Iter;
#[test]
fn bindgen_test_layout_SkDeque_F2BIter() {
    assert_eq!(
        ::core::mem::size_of::<SkDeque_F2BIter>(),
        24usize,
        concat!("Size of: ", stringify!(SkDeque_F2BIter))
    );
    assert_eq!(
        ::core::mem::align_of::<SkDeque_F2BIter>(),
        8usize,
        concat!("Alignment of ", stringify!(SkDeque_F2BIter))
    );
}
#[test]
fn bindgen_test_layout_SkDeque() {
    assert_eq!(
        ::core::mem::size_of::<SkDeque>(),
        56usize,
        concat!("Size of: ", stringify!(SkDeque))
    );
    assert_eq!(
        ::core::mem::align_of::<SkDeque>(),
        8usize,
        concat!("Alignment of ", stringify!(SkDeque))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkDeque10push_frontEv"]
    pub fn SkDeque_push_front(this: *mut SkDeque) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkDeque9push_backEv"]
    pub fn SkDeque_push_back(this: *mut SkDeque) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkDeque9pop_frontEv"]
    pub fn SkDeque_pop_front(this: *mut SkDeque);
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkDeque8pop_backEv"]
    pub fn SkDeque_pop_back(this: *mut SkDeque);
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkDequeC1Emi"]
    pub fn SkDeque_SkDeque(this: *mut SkDeque, elemSize: usize, allocCount: ::std::os::raw::c_int);
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkDequeC1EmPvmi"]
    pub fn SkDeque_SkDeque1(
        this: *mut SkDeque,
        elemSize: usize,
        storage: *mut ::std::os::raw::c_void,
        storageSize: usize,
        allocCount: ::std::os::raw::c_int,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkDequeD1Ev"]
    pub fn SkDeque_SkDeque_destructor(this: *mut SkDeque);
}
impl SkDeque {
    #[inline]
    pub unsafe fn push_front(&mut self) -> *mut ::std::os::raw::c_void {
        SkDeque_push_front(self)
    }
    #[inline]
    pub unsafe fn push_back(&mut self) -> *mut ::std::os::raw::c_void {
        SkDeque_push_back(self)
    }
    #[inline]
    pub unsafe fn pop_front(&mut self) {
        SkDeque_pop_front(self)
    }
    #[inline]
    pub unsafe fn pop_back(&mut self) {
        SkDeque_pop_back(self)
    }
    #[inline]
    pub unsafe fn new(elemSize: usize, allocCount: ::std::os::raw::c_int) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkDeque_SkDeque(&mut __bindgen_tmp, elemSize, allocCount);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(
        elemSize: usize,
        storage: *mut ::std::os::raw::c_void,
        storageSize: usize,
        allocCount: ::std::os::raw::c_int,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkDeque_SkDeque1(
            &mut __bindgen_tmp,
            elemSize,
            storage,
            storageSize,
            allocCount,
        );
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        SkDeque_SkDeque_destructor(self)
    }
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkTextEncoding {
    kUTF8 = 0,
    kUTF16 = 1,
    kUTF32 = 2,
    kGlyphID = 3,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkFontHinting {
    kNone = 0,
    kSlight = 1,
    kNormal = 2,
    kFull = 3,
}
impl SkFilterQuality {
    pub const kLast_SkFilterQuality: SkFilterQuality = SkFilterQuality::kHigh_SkFilterQuality;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkFilterQuality {
    kNone_SkFilterQuality = 0,
    kLow_SkFilterQuality = 1,
    kMedium_SkFilterQuality = 2,
    kHigh_SkFilterQuality = 3,
}
#[repr(C)]
pub struct SkPaint {
    pub fPathEffect: sk_sp<SkPathEffect>,
    pub fShader: sk_sp<SkShader>,
    pub fMaskFilter: sk_sp<SkMaskFilter>,
    pub fColorFilter: sk_sp<SkColorFilter>,
    pub fDrawLooper: sk_sp<SkDrawLooper>,
    pub fImageFilter: sk_sp<SkImageFilter>,
    pub fColor4f: SkColor4f,
    pub fWidth: SkScalar,
    pub fMiterLimit: SkScalar,
    pub __bindgen_anon_1: SkPaint__bindgen_ty_1,
}
#[repr(u8)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkPaint_Style {
    kFill_Style = 0,
    kStroke_Style = 1,
    kStrokeAndFill_Style = 2,
}
impl SkPaint_Cap {
    pub const kLast_Cap: SkPaint_Cap = SkPaint_Cap::kSquare_Cap;
}
impl SkPaint_Cap {
    pub const kDefault_Cap: SkPaint_Cap = SkPaint_Cap::kButt_Cap;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkPaint_Cap {
    kButt_Cap = 0,
    kRound_Cap = 1,
    kSquare_Cap = 2,
}
impl SkPaint_Join {
    pub const kLast_Join: SkPaint_Join = SkPaint_Join::kBevel_Join;
}
impl SkPaint_Join {
    pub const kDefault_Join: SkPaint_Join = SkPaint_Join::kMiter_Join;
}
#[repr(u8)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkPaint_Join {
    kMiter_Join = 0,
    kRound_Join = 1,
    kBevel_Join = 2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union SkPaint__bindgen_ty_1 {
    pub fBitfields: SkPaint__bindgen_ty_1__bindgen_ty_1,
    pub fBitfieldsUInt: u32,
    _bindgen_union_align: u32,
}
#[repr(C)]
#[repr(align(4))]
#[derive(Copy, Clone)]
pub struct SkPaint__bindgen_ty_1__bindgen_ty_1 {
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u16>,
}
#[test]
fn bindgen_test_layout_SkPaint__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<SkPaint__bindgen_ty_1__bindgen_ty_1>(),
        4usize,
        concat!("Size of: ", stringify!(SkPaint__bindgen_ty_1__bindgen_ty_1))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPaint__bindgen_ty_1__bindgen_ty_1>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(SkPaint__bindgen_ty_1__bindgen_ty_1)
        )
    );
}
impl SkPaint__bindgen_ty_1__bindgen_ty_1 {
    #[inline]
    pub fn fAntiAlias(&self) -> ::std::os::raw::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_fAntiAlias(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn fDither(&self) -> ::std::os::raw::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_fDither(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(1usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn fCapType(&self) -> ::std::os::raw::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u32) }
    }
    #[inline]
    pub fn set_fCapType(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(2usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub fn fJoinType(&self) -> ::std::os::raw::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u32) }
    }
    #[inline]
    pub fn set_fJoinType(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(4usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub fn fStyle(&self) -> ::std::os::raw::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u32) }
    }
    #[inline]
    pub fn set_fStyle(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(6usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub fn fFilterQuality(&self) -> ::std::os::raw::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(8usize, 2u8) as u32) }
    }
    #[inline]
    pub fn set_fFilterQuality(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(8usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub fn fBlendMode(&self) -> ::std::os::raw::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(10usize, 8u8) as u32) }
    }
    #[inline]
    pub fn set_fBlendMode(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(10usize, 8u8, val as u64)
        }
    }
    #[inline]
    pub fn fPadding(&self) -> ::std::os::raw::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(18usize, 14u8) as u32) }
    }
    #[inline]
    pub fn set_fPadding(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(18usize, 14u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        fAntiAlias: ::std::os::raw::c_uint,
        fDither: ::std::os::raw::c_uint,
        fCapType: ::std::os::raw::c_uint,
        fJoinType: ::std::os::raw::c_uint,
        fStyle: ::std::os::raw::c_uint,
        fFilterQuality: ::std::os::raw::c_uint,
        fBlendMode: ::std::os::raw::c_uint,
        fPadding: ::std::os::raw::c_uint,
    ) -> __BindgenBitfieldUnit<[u8; 4usize], u16> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u16> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let fAntiAlias: u32 = unsafe { ::core::mem::transmute(fAntiAlias) };
            fAntiAlias as u64
        });
        __bindgen_bitfield_unit.set(1usize, 1u8, {
            let fDither: u32 = unsafe { ::core::mem::transmute(fDither) };
            fDither as u64
        });
        __bindgen_bitfield_unit.set(2usize, 2u8, {
            let fCapType: u32 = unsafe { ::core::mem::transmute(fCapType) };
            fCapType as u64
        });
        __bindgen_bitfield_unit.set(4usize, 2u8, {
            let fJoinType: u32 = unsafe { ::core::mem::transmute(fJoinType) };
            fJoinType as u64
        });
        __bindgen_bitfield_unit.set(6usize, 2u8, {
            let fStyle: u32 = unsafe { ::core::mem::transmute(fStyle) };
            fStyle as u64
        });
        __bindgen_bitfield_unit.set(8usize, 2u8, {
            let fFilterQuality: u32 = unsafe { ::core::mem::transmute(fFilterQuality) };
            fFilterQuality as u64
        });
        __bindgen_bitfield_unit.set(10usize, 8u8, {
            let fBlendMode: u32 = unsafe { ::core::mem::transmute(fBlendMode) };
            fBlendMode as u64
        });
        __bindgen_bitfield_unit.set(18usize, 14u8, {
            let fPadding: u32 = unsafe { ::core::mem::transmute(fPadding) };
            fPadding as u64
        });
        __bindgen_bitfield_unit
    }
}
#[test]
fn bindgen_test_layout_SkPaint__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<SkPaint__bindgen_ty_1>(),
        4usize,
        concat!("Size of: ", stringify!(SkPaint__bindgen_ty_1))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPaint__bindgen_ty_1>(),
        4usize,
        concat!("Alignment of ", stringify!(SkPaint__bindgen_ty_1))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkPaint__bindgen_ty_1>())).fBitfields as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPaint__bindgen_ty_1),
            "::",
            stringify!(fBitfields)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkPaint__bindgen_ty_1>())).fBitfieldsUInt as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPaint__bindgen_ty_1),
            "::",
            stringify!(fBitfieldsUInt)
        )
    );
}
pub const SkPaint_kStyleCount: ::std::os::raw::c_int = 3;
pub const SkPaint_kCapCount: ::std::os::raw::c_int = 3;
pub const SkPaint_kJoinCount: ::std::os::raw::c_int = 3;
#[test]
fn bindgen_test_layout_SkPaint() {
    assert_eq!(
        ::core::mem::size_of::<SkPaint>(),
        80usize,
        concat!("Size of: ", stringify!(SkPaint))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPaint>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPaint))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPaint>())).fPathEffect as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPaint),
            "::",
            stringify!(fPathEffect)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPaint>())).fShader as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPaint),
            "::",
            stringify!(fShader)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPaint>())).fMaskFilter as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPaint),
            "::",
            stringify!(fMaskFilter)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPaint>())).fColorFilter as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPaint),
            "::",
            stringify!(fColorFilter)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPaint>())).fDrawLooper as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPaint),
            "::",
            stringify!(fDrawLooper)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPaint>())).fImageFilter as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPaint),
            "::",
            stringify!(fImageFilter)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPaint>())).fColor4f as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPaint),
            "::",
            stringify!(fColor4f)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPaint>())).fWidth as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPaint),
            "::",
            stringify!(fWidth)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPaint>())).fMiterLimit as *const _ as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPaint),
            "::",
            stringify!(fMiterLimit)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkPaint7getHashEv"]
    pub fn SkPaint_getHash(this: *const SkPaint) -> u32;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaint5resetEv"]
    pub fn SkPaint_reset(this: *mut SkPaint);
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaint16setFilterQualityE15SkFilterQuality"]
    pub fn SkPaint_setFilterQuality(this: *mut SkPaint, quality: SkFilterQuality);
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaint8setStyleENS_5StyleE"]
    pub fn SkPaint_setStyle(this: *mut SkPaint, style: SkPaint_Style);
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaint8setColorEj"]
    pub fn SkPaint_setColor(this: *mut SkPaint, color: SkColor);
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaint8setColorERK8SkRGBA4fIL11SkAlphaType3EEP12SkColorSpace"]
    pub fn SkPaint_setColor1(
        this: *mut SkPaint,
        color: *const SkColor4f,
        colorSpace: *mut SkColorSpace,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaint9setAlphafEf"]
    pub fn SkPaint_setAlphaf(this: *mut SkPaint, a: f32);
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaint7setARGBEjjjj"]
    pub fn SkPaint_setARGB(this: *mut SkPaint, a: U8CPU, r: U8CPU, g: U8CPU, b: U8CPU);
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaint14setStrokeWidthEf"]
    pub fn SkPaint_setStrokeWidth(this: *mut SkPaint, width: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaint14setStrokeMiterEf"]
    pub fn SkPaint_setStrokeMiter(this: *mut SkPaint, miter: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaint12setStrokeCapENS_3CapE"]
    pub fn SkPaint_setStrokeCap(this: *mut SkPaint, cap: SkPaint_Cap);
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaint13setStrokeJoinENS_4JoinE"]
    pub fn SkPaint_setStrokeJoin(this: *mut SkPaint, join: SkPaint_Join);
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkPaint11getFillPathERK6SkPathPS0_PK6SkRectf"]
    pub fn SkPaint_getFillPath(
        this: *const SkPaint,
        src: *const SkPath,
        dst: *mut SkPath,
        cullRect: *const SkRect,
        resScale: SkScalar,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkPaint9refShaderEv"]
    pub fn SkPaint_refShader(this: *const SkPaint) -> sk_sp<SkShader>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaint9setShaderE5sk_spI8SkShaderE"]
    pub fn SkPaint_setShader(this: *mut SkPaint, shader: sk_sp<SkShader>);
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkPaint14refColorFilterEv"]
    pub fn SkPaint_refColorFilter(this: *const SkPaint) -> sk_sp<SkColorFilter>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaint14setColorFilterE5sk_spI13SkColorFilterE"]
    pub fn SkPaint_setColorFilter(this: *mut SkPaint, colorFilter: sk_sp<SkColorFilter>);
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkPaint13refPathEffectEv"]
    pub fn SkPaint_refPathEffect(this: *const SkPaint) -> sk_sp<SkPathEffect>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaint13setPathEffectE5sk_spI12SkPathEffectE"]
    pub fn SkPaint_setPathEffect(this: *mut SkPaint, pathEffect: sk_sp<SkPathEffect>);
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkPaint13refMaskFilterEv"]
    pub fn SkPaint_refMaskFilter(this: *const SkPaint) -> sk_sp<SkMaskFilter>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaint13setMaskFilterE5sk_spI12SkMaskFilterE"]
    pub fn SkPaint_setMaskFilter(this: *mut SkPaint, maskFilter: sk_sp<SkMaskFilter>);
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkPaint14refImageFilterEv"]
    pub fn SkPaint_refImageFilter(this: *const SkPaint) -> sk_sp<SkImageFilter>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaint14setImageFilterE5sk_spI13SkImageFilterE"]
    pub fn SkPaint_setImageFilter(this: *mut SkPaint, imageFilter: sk_sp<SkImageFilter>);
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkPaint13nothingToDrawEv"]
    pub fn SkPaint_nothingToDraw(this: *const SkPaint) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkPaint20canComputeFastBoundsEv"]
    pub fn SkPaint_canComputeFastBounds(this: *const SkPaint) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkPaint19doComputeFastBoundsERK6SkRectPS0_NS_5StyleE"]
    pub fn SkPaint_doComputeFastBounds(
        this: *const SkPaint,
        orig: *const SkRect,
        storage: *mut SkRect,
        style: SkPaint_Style,
    ) -> *const SkRect;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaintC1Ev"]
    pub fn SkPaint_SkPaint(this: *mut SkPaint);
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaintC1ERK8SkRGBA4fIL11SkAlphaType3EEP12SkColorSpace"]
    pub fn SkPaint_SkPaint1(
        this: *mut SkPaint,
        color: *const SkColor4f,
        colorSpace: *mut SkColorSpace,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaintC1ERKS_"]
    pub fn SkPaint_SkPaint2(this: *mut SkPaint, paint: *const SkPaint);
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaintC1EOS_"]
    pub fn SkPaint_SkPaint3(this: *mut SkPaint, paint: *mut SkPaint);
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkPaintD1Ev"]
    pub fn SkPaint_SkPaint_destructor(this: *mut SkPaint);
}
impl SkPaint {
    #[inline]
    pub unsafe fn getHash(&self) -> u32 {
        SkPaint_getHash(self)
    }
    #[inline]
    pub unsafe fn reset(&mut self) {
        SkPaint_reset(self)
    }
    #[inline]
    pub unsafe fn setFilterQuality(&mut self, quality: SkFilterQuality) {
        SkPaint_setFilterQuality(self, quality)
    }
    #[inline]
    pub unsafe fn setStyle(&mut self, style: SkPaint_Style) {
        SkPaint_setStyle(self, style)
    }
    #[inline]
    pub unsafe fn setColor(&mut self, color: SkColor) {
        SkPaint_setColor(self, color)
    }
    #[inline]
    pub unsafe fn setColor1(&mut self, color: *const SkColor4f, colorSpace: *mut SkColorSpace) {
        SkPaint_setColor1(self, color, colorSpace)
    }
    #[inline]
    pub unsafe fn setAlphaf(&mut self, a: f32) {
        SkPaint_setAlphaf(self, a)
    }
    #[inline]
    pub unsafe fn setARGB(&mut self, a: U8CPU, r: U8CPU, g: U8CPU, b: U8CPU) {
        SkPaint_setARGB(self, a, r, g, b)
    }
    #[inline]
    pub unsafe fn setStrokeWidth(&mut self, width: SkScalar) {
        SkPaint_setStrokeWidth(self, width)
    }
    #[inline]
    pub unsafe fn setStrokeMiter(&mut self, miter: SkScalar) {
        SkPaint_setStrokeMiter(self, miter)
    }
    #[inline]
    pub unsafe fn setStrokeCap(&mut self, cap: SkPaint_Cap) {
        SkPaint_setStrokeCap(self, cap)
    }
    #[inline]
    pub unsafe fn setStrokeJoin(&mut self, join: SkPaint_Join) {
        SkPaint_setStrokeJoin(self, join)
    }
    #[inline]
    pub unsafe fn getFillPath(
        &self,
        src: *const SkPath,
        dst: *mut SkPath,
        cullRect: *const SkRect,
        resScale: SkScalar,
    ) -> bool {
        SkPaint_getFillPath(self, src, dst, cullRect, resScale)
    }
    #[inline]
    pub unsafe fn refShader(&self) -> sk_sp<SkShader> {
        SkPaint_refShader(self)
    }
    #[inline]
    pub unsafe fn setShader(&mut self, shader: sk_sp<SkShader>) {
        SkPaint_setShader(self, shader)
    }
    #[inline]
    pub unsafe fn refColorFilter(&self) -> sk_sp<SkColorFilter> {
        SkPaint_refColorFilter(self)
    }
    #[inline]
    pub unsafe fn setColorFilter(&mut self, colorFilter: sk_sp<SkColorFilter>) {
        SkPaint_setColorFilter(self, colorFilter)
    }
    #[inline]
    pub unsafe fn refPathEffect(&self) -> sk_sp<SkPathEffect> {
        SkPaint_refPathEffect(self)
    }
    #[inline]
    pub unsafe fn setPathEffect(&mut self, pathEffect: sk_sp<SkPathEffect>) {
        SkPaint_setPathEffect(self, pathEffect)
    }
    #[inline]
    pub unsafe fn refMaskFilter(&self) -> sk_sp<SkMaskFilter> {
        SkPaint_refMaskFilter(self)
    }
    #[inline]
    pub unsafe fn setMaskFilter(&mut self, maskFilter: sk_sp<SkMaskFilter>) {
        SkPaint_setMaskFilter(self, maskFilter)
    }
    #[inline]
    pub unsafe fn refImageFilter(&self) -> sk_sp<SkImageFilter> {
        SkPaint_refImageFilter(self)
    }
    #[inline]
    pub unsafe fn setImageFilter(&mut self, imageFilter: sk_sp<SkImageFilter>) {
        SkPaint_setImageFilter(self, imageFilter)
    }
    #[inline]
    pub unsafe fn nothingToDraw(&self) -> bool {
        SkPaint_nothingToDraw(self)
    }
    #[inline]
    pub unsafe fn canComputeFastBounds(&self) -> bool {
        SkPaint_canComputeFastBounds(self)
    }
    #[inline]
    pub unsafe fn doComputeFastBounds(
        &self,
        orig: *const SkRect,
        storage: *mut SkRect,
        style: SkPaint_Style,
    ) -> *const SkRect {
        SkPaint_doComputeFastBounds(self, orig, storage, style)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkPaint_SkPaint(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(color: *const SkColor4f, colorSpace: *mut SkColorSpace) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkPaint_SkPaint1(&mut __bindgen_tmp, color, colorSpace);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new2(paint: *const SkPaint) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkPaint_SkPaint2(&mut __bindgen_tmp, paint);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new3(paint: *mut SkPaint) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkPaint_SkPaint3(&mut __bindgen_tmp, paint);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        SkPaint_SkPaint_destructor(self)
    }
}
#[repr(C)]
pub struct SkRasterHandleAllocator__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
pub struct SkRasterHandleAllocator {
    pub vtable_: *const SkRasterHandleAllocator__bindgen_vtable,
}
pub type SkRasterHandleAllocator_Handle = *mut ::std::os::raw::c_void;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkRasterHandleAllocator_Rec {
    pub fReleaseProc: ::core::option::Option<
        unsafe extern "C" fn(pixels: *mut ::std::os::raw::c_void, ctx: *mut ::std::os::raw::c_void),
    >,
    pub fReleaseCtx: *mut ::std::os::raw::c_void,
    pub fPixels: *mut ::std::os::raw::c_void,
    pub fRowBytes: usize,
    pub fHandle: SkRasterHandleAllocator_Handle,
}
#[test]
fn bindgen_test_layout_SkRasterHandleAllocator_Rec() {
    assert_eq!(
        ::core::mem::size_of::<SkRasterHandleAllocator_Rec>(),
        40usize,
        concat!("Size of: ", stringify!(SkRasterHandleAllocator_Rec))
    );
    assert_eq!(
        ::core::mem::align_of::<SkRasterHandleAllocator_Rec>(),
        8usize,
        concat!("Alignment of ", stringify!(SkRasterHandleAllocator_Rec))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkRasterHandleAllocator_Rec>())).fReleaseProc as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRasterHandleAllocator_Rec),
            "::",
            stringify!(fReleaseProc)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkRasterHandleAllocator_Rec>())).fReleaseCtx as *const _
                as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRasterHandleAllocator_Rec),
            "::",
            stringify!(fReleaseCtx)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkRasterHandleAllocator_Rec>())).fPixels as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRasterHandleAllocator_Rec),
            "::",
            stringify!(fPixels)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkRasterHandleAllocator_Rec>())).fRowBytes as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRasterHandleAllocator_Rec),
            "::",
            stringify!(fRowBytes)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkRasterHandleAllocator_Rec>())).fHandle as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRasterHandleAllocator_Rec),
            "::",
            stringify!(fHandle)
        )
    );
}
#[test]
fn bindgen_test_layout_SkRasterHandleAllocator() {
    assert_eq!(
        ::core::mem::size_of::<SkRasterHandleAllocator>(),
        8usize,
        concat!("Size of: ", stringify!(SkRasterHandleAllocator))
    );
    assert_eq!(
        ::core::mem::align_of::<SkRasterHandleAllocator>(),
        8usize,
        concat!("Alignment of ", stringify!(SkRasterHandleAllocator))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN23SkRasterHandleAllocator10MakeCanvasESt10unique_ptrIS_St14default_deleteIS_EERK11SkImageInfoPKNS_3RecE"]
    pub fn SkRasterHandleAllocator_MakeCanvas(
        arg1: u64,
        arg2: *const SkImageInfo,
        rec: *const SkRasterHandleAllocator_Rec,
    ) -> u64;
}
impl SkRasterHandleAllocator {
    #[inline]
    pub unsafe fn MakeCanvas(
        arg1: u64,
        arg2: *const SkImageInfo,
        rec: *const SkRasterHandleAllocator_Rec,
    ) -> u64 {
        SkRasterHandleAllocator_MakeCanvas(arg1, arg2, rec)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkAutoTMalloc {
    pub _address: u8,
}
#[repr(C)]
pub union SkTArray__bindgen_ty_1<T> {
    pub fItemArray: *mut T,
    pub fMemArray: *mut ::std::os::raw::c_void,
    _bindgen_union_align: u64,
    pub _phantom_0: ::core::marker::PhantomData<::core::cell::UnsafeCell<T>>,
}
pub type SkSTArray_INHERITED = u8;
#[repr(C)]
pub struct SkString {
    pub fRec: sk_sp<SkString_Rec>,
}
#[repr(C)]
pub struct SkString_Rec {
    pub fLength: u32,
    pub fRefCnt: u32,
    pub fBeginningOfData: ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_SkString_Rec() {
    assert_eq!(
        ::core::mem::size_of::<SkString_Rec>(),
        12usize,
        concat!("Size of: ", stringify!(SkString_Rec))
    );
    assert_eq!(
        ::core::mem::align_of::<SkString_Rec>(),
        4usize,
        concat!("Alignment of ", stringify!(SkString_Rec))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkString_Rec>())).fLength as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkString_Rec),
            "::",
            stringify!(fLength)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkString_Rec>())).fRefCnt as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkString_Rec),
            "::",
            stringify!(fRefCnt)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkString_Rec>())).fBeginningOfData as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkString_Rec),
            "::",
            stringify!(fBeginningOfData)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString3Rec4MakeEPKcm"]
    pub fn SkString_Rec_Make(
        text: *const ::std::os::raw::c_char,
        len: usize,
    ) -> sk_sp<SkString_Rec>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkString3Rec3refEv"]
    pub fn SkString_Rec_ref(this: *const SkString_Rec);
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkString3Rec5unrefEv"]
    pub fn SkString_Rec_unref(this: *const SkString_Rec);
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkString3Rec6uniqueEv"]
    pub fn SkString_Rec_unique(this: *const SkString_Rec) -> bool;
}
impl SkString_Rec {
    #[inline]
    pub unsafe fn Make(text: *const ::std::os::raw::c_char, len: usize) -> sk_sp<SkString_Rec> {
        SkString_Rec_Make(text, len)
    }
    #[inline]
    pub unsafe fn ref_(&self) {
        SkString_Rec_ref(self)
    }
    #[inline]
    pub unsafe fn unref(&self) {
        SkString_Rec_unref(self)
    }
    #[inline]
    pub unsafe fn unique(&self) -> bool {
        SkString_Rec_unique(self)
    }
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString9gEmptyRecE"]
    pub static SkString_gEmptyRec: SkString_Rec;
}
#[test]
fn bindgen_test_layout_SkString() {
    assert_eq!(
        ::core::mem::size_of::<SkString>(),
        8usize,
        concat!("Size of: ", stringify!(SkString))
    );
    assert_eq!(
        ::core::mem::align_of::<SkString>(),
        8usize,
        concat!("Alignment of ", stringify!(SkString))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkString>())).fRec as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkString),
            "::",
            stringify!(fRec)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkString6equalsERKS_"]
    pub fn SkString_equals(this: *const SkString, arg1: *const SkString) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkString6equalsEPKc"]
    pub fn SkString_equals1(this: *const SkString, text: *const ::std::os::raw::c_char) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkString6equalsEPKcm"]
    pub fn SkString_equals2(
        this: *const SkString,
        text: *const ::std::os::raw::c_char,
        len: usize,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString12writable_strEv"]
    pub fn SkString_writable_str(this: *mut SkString) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString5resetEv"]
    pub fn SkString_reset(this: *mut SkString);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString3setEPKc"]
    pub fn SkString_set(this: *mut SkString, text: *const ::std::os::raw::c_char);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString3setEPKcm"]
    pub fn SkString_set1(this: *mut SkString, text: *const ::std::os::raw::c_char, len: usize);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString6insertEmPKc"]
    pub fn SkString_insert(this: *mut SkString, offset: usize, text: *const ::std::os::raw::c_char);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString6insertEmPKcm"]
    pub fn SkString_insert1(
        this: *mut SkString,
        offset: usize,
        text: *const ::std::os::raw::c_char,
        len: usize,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString13insertUnicharEmi"]
    pub fn SkString_insertUnichar(this: *mut SkString, offset: usize, arg1: SkUnichar);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString9insertS32Emi"]
    pub fn SkString_insertS32(this: *mut SkString, offset: usize, value: i32);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString9insertS64Emli"]
    pub fn SkString_insertS64(
        this: *mut SkString,
        offset: usize,
        value: i64,
        minDigits: ::std::os::raw::c_int,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString9insertU32Emj"]
    pub fn SkString_insertU32(this: *mut SkString, offset: usize, value: u32);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString9insertU64Emmi"]
    pub fn SkString_insertU64(
        this: *mut SkString,
        offset: usize,
        value: u64,
        minDigits: ::std::os::raw::c_int,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString9insertHexEmji"]
    pub fn SkString_insertHex(
        this: *mut SkString,
        offset: usize,
        value: u32,
        minDigits: ::std::os::raw::c_int,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString12insertScalarEmf"]
    pub fn SkString_insertScalar(this: *mut SkString, offset: usize, arg1: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString6printfEPKcz"]
    pub fn SkString_printf(this: *mut SkString, format: *const ::std::os::raw::c_char, ...);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString7appendfEPKcz"]
    pub fn SkString_appendf(this: *mut SkString, format: *const ::std::os::raw::c_char, ...);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString12appendVAListEPKcP13__va_list_tag"]
    pub fn SkString_appendVAList(
        this: *mut SkString,
        format: *const ::std::os::raw::c_char,
        arg1: *mut __va_list_tag,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString8prependfEPKcz"]
    pub fn SkString_prependf(this: *mut SkString, format: *const ::std::os::raw::c_char, ...);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString13prependVAListEPKcP13__va_list_tag"]
    pub fn SkString_prependVAList(
        this: *mut SkString,
        format: *const ::std::os::raw::c_char,
        arg1: *mut __va_list_tag,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString6removeEmm"]
    pub fn SkString_remove(this: *mut SkString, offset: usize, length: usize);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkString4swapERS_"]
    pub fn SkString_swap(this: *mut SkString, other: *mut SkString);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkStringC1Ev"]
    pub fn SkString_SkString(this: *mut SkString);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkStringC1Em"]
    pub fn SkString_SkString1(this: *mut SkString, len: usize);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkStringC1EPKc"]
    pub fn SkString_SkString2(this: *mut SkString, text: *const ::std::os::raw::c_char);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkStringC1EPKcm"]
    pub fn SkString_SkString3(this: *mut SkString, text: *const ::std::os::raw::c_char, len: usize);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkStringC1ERKS_"]
    pub fn SkString_SkString4(this: *mut SkString, arg1: *const SkString);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkStringC1EOS_"]
    pub fn SkString_SkString5(this: *mut SkString, arg1: *mut SkString);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkStringD1Ev"]
    pub fn SkString_SkString_destructor(this: *mut SkString);
}
impl SkString {
    #[inline]
    pub unsafe fn equals(&self, arg1: *const SkString) -> bool {
        SkString_equals(self, arg1)
    }
    #[inline]
    pub unsafe fn equals1(&self, text: *const ::std::os::raw::c_char) -> bool {
        SkString_equals1(self, text)
    }
    #[inline]
    pub unsafe fn equals2(&self, text: *const ::std::os::raw::c_char, len: usize) -> bool {
        SkString_equals2(self, text, len)
    }
    #[inline]
    pub unsafe fn writable_str(&mut self) -> *mut ::std::os::raw::c_char {
        SkString_writable_str(self)
    }
    #[inline]
    pub unsafe fn reset(&mut self) {
        SkString_reset(self)
    }
    #[inline]
    pub unsafe fn set(&mut self, text: *const ::std::os::raw::c_char) {
        SkString_set(self, text)
    }
    #[inline]
    pub unsafe fn set1(&mut self, text: *const ::std::os::raw::c_char, len: usize) {
        SkString_set1(self, text, len)
    }
    #[inline]
    pub unsafe fn insert(&mut self, offset: usize, text: *const ::std::os::raw::c_char) {
        SkString_insert(self, offset, text)
    }
    #[inline]
    pub unsafe fn insert1(
        &mut self,
        offset: usize,
        text: *const ::std::os::raw::c_char,
        len: usize,
    ) {
        SkString_insert1(self, offset, text, len)
    }
    #[inline]
    pub unsafe fn insertUnichar(&mut self, offset: usize, arg1: SkUnichar) {
        SkString_insertUnichar(self, offset, arg1)
    }
    #[inline]
    pub unsafe fn insertS32(&mut self, offset: usize, value: i32) {
        SkString_insertS32(self, offset, value)
    }
    #[inline]
    pub unsafe fn insertS64(
        &mut self,
        offset: usize,
        value: i64,
        minDigits: ::std::os::raw::c_int,
    ) {
        SkString_insertS64(self, offset, value, minDigits)
    }
    #[inline]
    pub unsafe fn insertU32(&mut self, offset: usize, value: u32) {
        SkString_insertU32(self, offset, value)
    }
    #[inline]
    pub unsafe fn insertU64(
        &mut self,
        offset: usize,
        value: u64,
        minDigits: ::std::os::raw::c_int,
    ) {
        SkString_insertU64(self, offset, value, minDigits)
    }
    #[inline]
    pub unsafe fn insertHex(
        &mut self,
        offset: usize,
        value: u32,
        minDigits: ::std::os::raw::c_int,
    ) {
        SkString_insertHex(self, offset, value, minDigits)
    }
    #[inline]
    pub unsafe fn insertScalar(&mut self, offset: usize, arg1: SkScalar) {
        SkString_insertScalar(self, offset, arg1)
    }
    #[inline]
    pub unsafe fn appendVAList(
        &mut self,
        format: *const ::std::os::raw::c_char,
        arg1: *mut __va_list_tag,
    ) {
        SkString_appendVAList(self, format, arg1)
    }
    #[inline]
    pub unsafe fn prependVAList(
        &mut self,
        format: *const ::std::os::raw::c_char,
        arg1: *mut __va_list_tag,
    ) {
        SkString_prependVAList(self, format, arg1)
    }
    #[inline]
    pub unsafe fn remove(&mut self, offset: usize, length: usize) {
        SkString_remove(self, offset, length)
    }
    #[inline]
    pub unsafe fn swap(&mut self, other: *mut SkString) {
        SkString_swap(self, other)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkString_SkString(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(len: usize) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkString_SkString1(&mut __bindgen_tmp, len);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new2(text: *const ::std::os::raw::c_char) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkString_SkString2(&mut __bindgen_tmp, text);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new3(text: *const ::std::os::raw::c_char, len: usize) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkString_SkString3(&mut __bindgen_tmp, text, len);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new4(arg1: *const SkString) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkString_SkString4(&mut __bindgen_tmp, arg1);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new5(arg1: *mut SkString) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkString_SkString5(&mut __bindgen_tmp, arg1);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        SkString_SkString_destructor(self)
    }
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkPixelGeometry {
    kUnknown_SkPixelGeometry = 0,
    kRGB_H_SkPixelGeometry = 1,
    kBGR_H_SkPixelGeometry = 2,
    kRGB_V_SkPixelGeometry = 3,
    kBGR_V_SkPixelGeometry = 4,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkSurfaceProps {
    pub fFlags: u32,
    pub fPixelGeometry: SkPixelGeometry,
}
pub const SkSurfaceProps_Flags_kUseDeviceIndependentFonts_Flag: SkSurfaceProps_Flags = 1;
pub type SkSurfaceProps_Flags = u32;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkSurfaceProps_InitType {
    kLegacyFontHost_InitType = 0,
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkSurfaceProps27kUseDistanceFieldFonts_FlagE"]
    pub static SkSurfaceProps_kUseDistanceFieldFonts_Flag: SkSurfaceProps_Flags;
}
#[test]
fn bindgen_test_layout_SkSurfaceProps() {
    assert_eq!(
        ::core::mem::size_of::<SkSurfaceProps>(),
        8usize,
        concat!("Size of: ", stringify!(SkSurfaceProps))
    );
    assert_eq!(
        ::core::mem::align_of::<SkSurfaceProps>(),
        4usize,
        concat!("Alignment of ", stringify!(SkSurfaceProps))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkSurfaceProps>())).fFlags as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkSurfaceProps),
            "::",
            stringify!(fFlags)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkSurfaceProps>())).fPixelGeometry as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkSurfaceProps),
            "::",
            stringify!(fPixelGeometry)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkSurfacePropsC1Ej15SkPixelGeometry"]
    pub fn SkSurfaceProps_SkSurfaceProps(
        this: *mut SkSurfaceProps,
        flags: u32,
        arg1: SkPixelGeometry,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkSurfacePropsC1ENS_8InitTypeE"]
    pub fn SkSurfaceProps_SkSurfaceProps1(this: *mut SkSurfaceProps, arg1: SkSurfaceProps_InitType);
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkSurfacePropsC1EjNS_8InitTypeE"]
    pub fn SkSurfaceProps_SkSurfaceProps2(
        this: *mut SkSurfaceProps,
        flags: u32,
        arg1: SkSurfaceProps_InitType,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkSurfacePropsC1ERKS_"]
    pub fn SkSurfaceProps_SkSurfaceProps3(this: *mut SkSurfaceProps, other: *const SkSurfaceProps);
}
impl SkSurfaceProps {
    #[inline]
    pub unsafe fn new(flags: u32, arg1: SkPixelGeometry) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkSurfaceProps_SkSurfaceProps(&mut __bindgen_tmp, flags, arg1);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(arg1: SkSurfaceProps_InitType) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkSurfaceProps_SkSurfaceProps1(&mut __bindgen_tmp, arg1);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new2(flags: u32, arg1: SkSurfaceProps_InitType) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkSurfaceProps_SkSurfaceProps2(&mut __bindgen_tmp, flags, arg1);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new3(other: *const SkSurfaceProps) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkSurfaceProps_SkSurfaceProps3(&mut __bindgen_tmp, other);
        __bindgen_tmp
    }
}
#[repr(C)]
pub struct SkData {
    pub _base: SkNVRefCnt,
    pub fReleaseProc: SkData_ReleaseProc,
    pub fReleaseProcContext: *mut ::std::os::raw::c_void,
    pub fPtr: *mut ::std::os::raw::c_void,
    pub fSize: usize,
}
pub type SkData_ReleaseProc = ::core::option::Option<
    unsafe extern "C" fn(ptr: *const ::std::os::raw::c_void, context: *mut ::std::os::raw::c_void),
>;
pub type SkData_INHERITED = SkRefCnt;
#[test]
fn bindgen_test_layout_SkData() {
    assert_eq!(
        ::core::mem::size_of::<SkData>(),
        40usize,
        concat!("Size of: ", stringify!(SkData))
    );
    assert_eq!(
        ::core::mem::align_of::<SkData>(),
        8usize,
        concat!("Alignment of ", stringify!(SkData))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkData>())).fReleaseProc as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkData),
            "::",
            stringify!(fReleaseProc)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkData>())).fReleaseProcContext as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkData),
            "::",
            stringify!(fReleaseProcContext)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkData>())).fPtr as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkData),
            "::",
            stringify!(fPtr)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkData>())).fSize as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(SkData),
            "::",
            stringify!(fSize)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkData9copyRangeEmmPv"]
    pub fn SkData_copyRange(
        this: *const SkData,
        offset: usize,
        length: usize,
        buffer: *mut ::std::os::raw::c_void,
    ) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkData6equalsEPKS_"]
    pub fn SkData_equals(this: *const SkData, other: *const SkData) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkData12MakeWithCopyEPKvm"]
    pub fn SkData_MakeWithCopy(data: *const ::std::os::raw::c_void, length: usize)
        -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkData17MakeUninitializedEm"]
    pub fn SkData_MakeUninitialized(length: usize) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkData15MakeWithCStringEPKc"]
    pub fn SkData_MakeWithCString(cstr: *const ::std::os::raw::c_char) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkData12MakeWithProcEPKvmPFvS1_PvES2_"]
    pub fn SkData_MakeWithProc(
        ptr: *const ::std::os::raw::c_void,
        length: usize,
        proc_: SkData_ReleaseProc,
        ctx: *mut ::std::os::raw::c_void,
    ) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkData14MakeFromMallocEPKvm"]
    pub fn SkData_MakeFromMalloc(
        data: *const ::std::os::raw::c_void,
        length: usize,
    ) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkData16MakeFromFileNameEPKc"]
    pub fn SkData_MakeFromFileName(path: *const ::std::os::raw::c_char) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkData12MakeFromFILEEP8_IO_FILE"]
    pub fn SkData_MakeFromFILE(f: *mut FILE) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkData10MakeFromFDEi"]
    pub fn SkData_MakeFromFD(fd: ::std::os::raw::c_int) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkData14MakeFromStreamEP8SkStreamm"]
    pub fn SkData_MakeFromStream(arg1: *mut SkStream, size: usize) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkData10MakeSubsetEPKS_mm"]
    pub fn SkData_MakeSubset(src: *const SkData, offset: usize, length: usize) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkData9MakeEmptyEv"]
    pub fn SkData_MakeEmpty() -> sk_sp<SkData>;
}
impl SkData {
    #[inline]
    pub unsafe fn copyRange(
        &self,
        offset: usize,
        length: usize,
        buffer: *mut ::std::os::raw::c_void,
    ) -> usize {
        SkData_copyRange(self, offset, length, buffer)
    }
    #[inline]
    pub unsafe fn equals(&self, other: *const SkData) -> bool {
        SkData_equals(self, other)
    }
    #[inline]
    pub unsafe fn MakeWithCopy(
        data: *const ::std::os::raw::c_void,
        length: usize,
    ) -> sk_sp<SkData> {
        SkData_MakeWithCopy(data, length)
    }
    #[inline]
    pub unsafe fn MakeUninitialized(length: usize) -> sk_sp<SkData> {
        SkData_MakeUninitialized(length)
    }
    #[inline]
    pub unsafe fn MakeWithCString(cstr: *const ::std::os::raw::c_char) -> sk_sp<SkData> {
        SkData_MakeWithCString(cstr)
    }
    #[inline]
    pub unsafe fn MakeWithProc(
        ptr: *const ::std::os::raw::c_void,
        length: usize,
        proc_: SkData_ReleaseProc,
        ctx: *mut ::std::os::raw::c_void,
    ) -> sk_sp<SkData> {
        SkData_MakeWithProc(ptr, length, proc_, ctx)
    }
    #[inline]
    pub unsafe fn MakeFromMalloc(
        data: *const ::std::os::raw::c_void,
        length: usize,
    ) -> sk_sp<SkData> {
        SkData_MakeFromMalloc(data, length)
    }
    #[inline]
    pub unsafe fn MakeFromFileName(path: *const ::std::os::raw::c_char) -> sk_sp<SkData> {
        SkData_MakeFromFileName(path)
    }
    #[inline]
    pub unsafe fn MakeFromFILE(f: *mut FILE) -> sk_sp<SkData> {
        SkData_MakeFromFILE(f)
    }
    #[inline]
    pub unsafe fn MakeFromFD(fd: ::std::os::raw::c_int) -> sk_sp<SkData> {
        SkData_MakeFromFD(fd)
    }
    #[inline]
    pub unsafe fn MakeFromStream(arg1: *mut SkStream, size: usize) -> sk_sp<SkData> {
        SkData_MakeFromStream(arg1, size)
    }
    #[inline]
    pub unsafe fn MakeSubset(src: *const SkData, offset: usize, length: usize) -> sk_sp<SkData> {
        SkData_MakeSubset(src, offset, length)
    }
    #[inline]
    pub unsafe fn MakeEmpty() -> sk_sp<SkData> {
        SkData_MakeEmpty()
    }
}
#[repr(C)]
pub struct SkVertices {
    pub _base: SkNVRefCnt,
    pub fUniqueID: u32,
    pub fPositions: *mut SkPoint,
    pub fTexs: *mut SkPoint,
    pub fColors: *mut SkColor,
    pub fBoneIndices: *mut SkVertices_BoneIndices,
    pub fBoneWeights: *mut SkVertices_BoneWeights,
    pub fIndices: *mut u16,
    pub fBounds: SkRect,
    pub fVertexCnt: ::std::os::raw::c_int,
    pub fIndexCnt: ::std::os::raw::c_int,
    pub fIsVolatile: bool,
    pub fMode: SkVertices_VertexMode,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkVertices_BoneIndices {
    pub indices: [u32; 4usize],
}
#[test]
fn bindgen_test_layout_SkVertices_BoneIndices() {
    assert_eq!(
        ::core::mem::size_of::<SkVertices_BoneIndices>(),
        16usize,
        concat!("Size of: ", stringify!(SkVertices_BoneIndices))
    );
    assert_eq!(
        ::core::mem::align_of::<SkVertices_BoneIndices>(),
        4usize,
        concat!("Alignment of ", stringify!(SkVertices_BoneIndices))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkVertices_BoneIndices>())).indices as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkVertices_BoneIndices),
            "::",
            stringify!(indices)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkVertices_BoneWeights {
    pub weights: [f32; 4usize],
}
#[test]
fn bindgen_test_layout_SkVertices_BoneWeights() {
    assert_eq!(
        ::core::mem::size_of::<SkVertices_BoneWeights>(),
        16usize,
        concat!("Size of: ", stringify!(SkVertices_BoneWeights))
    );
    assert_eq!(
        ::core::mem::align_of::<SkVertices_BoneWeights>(),
        4usize,
        concat!("Alignment of ", stringify!(SkVertices_BoneWeights))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkVertices_BoneWeights>())).weights as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkVertices_BoneWeights),
            "::",
            stringify!(weights)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkVertices_Bone {
    pub values: [f32; 6usize],
}
#[test]
fn bindgen_test_layout_SkVertices_Bone() {
    assert_eq!(
        ::core::mem::size_of::<SkVertices_Bone>(),
        24usize,
        concat!("Size of: ", stringify!(SkVertices_Bone))
    );
    assert_eq!(
        ::core::mem::align_of::<SkVertices_Bone>(),
        4usize,
        concat!("Alignment of ", stringify!(SkVertices_Bone))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkVertices_Bone>())).values as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkVertices_Bone),
            "::",
            stringify!(values)
        )
    );
}
impl SkVertices_VertexMode {
    pub const kLast_VertexMode: SkVertices_VertexMode =
        SkVertices_VertexMode::kTriangleFan_VertexMode;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkVertices_VertexMode {
    kTriangles_VertexMode = 0,
    kTriangleStrip_VertexMode = 1,
    kTriangleFan_VertexMode = 2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkVertices_Sizes {
    _unused: [u8; 0],
}
pub const SkVertices_BuilderFlags_kHasTexCoords_BuilderFlag: SkVertices_BuilderFlags = 1;
pub const SkVertices_BuilderFlags_kHasColors_BuilderFlag: SkVertices_BuilderFlags = 2;
pub const SkVertices_BuilderFlags_kHasBones_BuilderFlag: SkVertices_BuilderFlags = 4;
pub const SkVertices_BuilderFlags_kIsNonVolatile_BuilderFlag: SkVertices_BuilderFlags = 8;
pub type SkVertices_BuilderFlags = u32;
#[repr(C)]
pub struct SkVertices_Builder {
    pub fVertices: sk_sp<SkVertices>,
    pub fIntermediateFanIndices: u64,
}
#[test]
fn bindgen_test_layout_SkVertices_Builder() {
    assert_eq!(
        ::core::mem::size_of::<SkVertices_Builder>(),
        16usize,
        concat!("Size of: ", stringify!(SkVertices_Builder))
    );
    assert_eq!(
        ::core::mem::align_of::<SkVertices_Builder>(),
        8usize,
        concat!("Alignment of ", stringify!(SkVertices_Builder))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkVertices_Builder>())).fVertices as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkVertices_Builder),
            "::",
            stringify!(fVertices)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkVertices_Builder>())).fIntermediateFanIndices as *const _
                as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkVertices_Builder),
            "::",
            stringify!(fIntermediateFanIndices)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkVertices7Builder11vertexCountEv"]
    pub fn SkVertices_Builder_vertexCount(this: *const SkVertices_Builder)
        -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkVertices7Builder10indexCountEv"]
    pub fn SkVertices_Builder_indexCount(this: *const SkVertices_Builder) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkVertices7Builder10isVolatileEv"]
    pub fn SkVertices_Builder_isVolatile(this: *const SkVertices_Builder) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkVertices7Builder9positionsEv"]
    pub fn SkVertices_Builder_positions(this: *mut SkVertices_Builder) -> *mut SkPoint;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkVertices7Builder9texCoordsEv"]
    pub fn SkVertices_Builder_texCoords(this: *mut SkVertices_Builder) -> *mut SkPoint;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkVertices7Builder6colorsEv"]
    pub fn SkVertices_Builder_colors(this: *mut SkVertices_Builder) -> *mut SkColor;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkVertices7Builder11boneIndicesEv"]
    pub fn SkVertices_Builder_boneIndices(
        this: *mut SkVertices_Builder,
    ) -> *mut SkVertices_BoneIndices;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkVertices7Builder11boneWeightsEv"]
    pub fn SkVertices_Builder_boneWeights(
        this: *mut SkVertices_Builder,
    ) -> *mut SkVertices_BoneWeights;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkVertices7Builder7indicesEv"]
    pub fn SkVertices_Builder_indices(this: *mut SkVertices_Builder) -> *mut u16;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkVertices7Builder6detachEv"]
    pub fn SkVertices_Builder_detach(this: *mut SkVertices_Builder) -> sk_sp<SkVertices>;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkVertices7BuilderC1ENS_10VertexModeEiij"]
    pub fn SkVertices_Builder_Builder(
        this: *mut SkVertices_Builder,
        mode: SkVertices_VertexMode,
        vertexCount: ::std::os::raw::c_int,
        indexCount: ::std::os::raw::c_int,
        flags: u32,
    );
}
impl SkVertices_Builder {
    #[inline]
    pub unsafe fn vertexCount(&self) -> ::std::os::raw::c_int {
        SkVertices_Builder_vertexCount(self)
    }
    #[inline]
    pub unsafe fn indexCount(&self) -> ::std::os::raw::c_int {
        SkVertices_Builder_indexCount(self)
    }
    #[inline]
    pub unsafe fn isVolatile(&self) -> bool {
        SkVertices_Builder_isVolatile(self)
    }
    #[inline]
    pub unsafe fn positions(&mut self) -> *mut SkPoint {
        SkVertices_Builder_positions(self)
    }
    #[inline]
    pub unsafe fn texCoords(&mut self) -> *mut SkPoint {
        SkVertices_Builder_texCoords(self)
    }
    #[inline]
    pub unsafe fn colors(&mut self) -> *mut SkColor {
        SkVertices_Builder_colors(self)
    }
    #[inline]
    pub unsafe fn boneIndices(&mut self) -> *mut SkVertices_BoneIndices {
        SkVertices_Builder_boneIndices(self)
    }
    #[inline]
    pub unsafe fn boneWeights(&mut self) -> *mut SkVertices_BoneWeights {
        SkVertices_Builder_boneWeights(self)
    }
    #[inline]
    pub unsafe fn indices(&mut self) -> *mut u16 {
        SkVertices_Builder_indices(self)
    }
    #[inline]
    pub unsafe fn detach(&mut self) -> sk_sp<SkVertices> {
        SkVertices_Builder_detach(self)
    }
    #[inline]
    pub unsafe fn new(
        mode: SkVertices_VertexMode,
        vertexCount: ::std::os::raw::c_int,
        indexCount: ::std::os::raw::c_int,
        flags: u32,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkVertices_Builder_Builder(&mut __bindgen_tmp, mode, vertexCount, indexCount, flags);
        __bindgen_tmp
    }
}
#[test]
fn bindgen_test_layout_SkVertices() {
    assert_eq!(
        ::core::mem::size_of::<SkVertices>(),
        88usize,
        concat!("Size of: ", stringify!(SkVertices))
    );
    assert_eq!(
        ::core::mem::align_of::<SkVertices>(),
        8usize,
        concat!("Alignment of ", stringify!(SkVertices))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkVertices>())).fUniqueID as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkVertices),
            "::",
            stringify!(fUniqueID)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkVertices>())).fPositions as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkVertices),
            "::",
            stringify!(fPositions)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkVertices>())).fTexs as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkVertices),
            "::",
            stringify!(fTexs)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkVertices>())).fColors as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkVertices),
            "::",
            stringify!(fColors)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkVertices>())).fBoneIndices as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(SkVertices),
            "::",
            stringify!(fBoneIndices)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkVertices>())).fBoneWeights as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(SkVertices),
            "::",
            stringify!(fBoneWeights)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkVertices>())).fIndices as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(SkVertices),
            "::",
            stringify!(fIndices)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkVertices>())).fBounds as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(SkVertices),
            "::",
            stringify!(fBounds)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkVertices>())).fVertexCnt as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(SkVertices),
            "::",
            stringify!(fVertexCnt)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkVertices>())).fIndexCnt as *const _ as usize },
        76usize,
        concat!(
            "Offset of field: ",
            stringify!(SkVertices),
            "::",
            stringify!(fIndexCnt)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkVertices>())).fIsVolatile as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(SkVertices),
            "::",
            stringify!(fIsVolatile)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkVertices>())).fMode as *const _ as usize },
        84usize,
        concat!(
            "Offset of field: ",
            stringify!(SkVertices),
            "::",
            stringify!(fMode)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkVertices8MakeCopyENS_10VertexModeEiPK7SkPointS3_PKjPKNS_11BoneIndicesEPKNS_11BoneWeightsEiPKtb"]
    pub fn SkVertices_MakeCopy(
        mode: SkVertices_VertexMode,
        vertexCount: ::std::os::raw::c_int,
        positions: *const SkPoint,
        texs: *const SkPoint,
        colors: *const SkColor,
        boneIndices: *const SkVertices_BoneIndices,
        boneWeights: *const SkVertices_BoneWeights,
        indexCount: ::std::os::raw::c_int,
        indices: *const u16,
        isVolatile: bool,
    ) -> sk_sp<SkVertices>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkVertices10applyBonesEPKNS_4BoneEi"]
    pub fn SkVertices_applyBones(
        this: *const SkVertices,
        bones: *const SkVertices_Bone,
        boneCount: ::std::os::raw::c_int,
    ) -> sk_sp<SkVertices>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkVertices15approximateSizeEv"]
    pub fn SkVertices_approximateSize(this: *const SkVertices) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkVertices6DecodeEPKvm"]
    pub fn SkVertices_Decode(
        buffer: *const ::std::os::raw::c_void,
        length: usize,
    ) -> sk_sp<SkVertices>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkVertices6encodeEv"]
    pub fn SkVertices_encode(this: *const SkVertices) -> sk_sp<SkData>;
}
impl SkVertices {
    #[inline]
    pub unsafe fn MakeCopy(
        mode: SkVertices_VertexMode,
        vertexCount: ::std::os::raw::c_int,
        positions: *const SkPoint,
        texs: *const SkPoint,
        colors: *const SkColor,
        boneIndices: *const SkVertices_BoneIndices,
        boneWeights: *const SkVertices_BoneWeights,
        indexCount: ::std::os::raw::c_int,
        indices: *const u16,
        isVolatile: bool,
    ) -> sk_sp<SkVertices> {
        SkVertices_MakeCopy(
            mode,
            vertexCount,
            positions,
            texs,
            colors,
            boneIndices,
            boneWeights,
            indexCount,
            indices,
            isVolatile,
        )
    }
    #[inline]
    pub unsafe fn applyBones(
        &self,
        bones: *const SkVertices_Bone,
        boneCount: ::std::os::raw::c_int,
    ) -> sk_sp<SkVertices> {
        SkVertices_applyBones(self, bones, boneCount)
    }
    #[inline]
    pub unsafe fn approximateSize(&self) -> usize {
        SkVertices_approximateSize(self)
    }
    #[inline]
    pub unsafe fn Decode(
        buffer: *const ::std::os::raw::c_void,
        length: usize,
    ) -> sk_sp<SkVertices> {
        SkVertices_Decode(buffer, length)
    }
    #[inline]
    pub unsafe fn encode(&self) -> sk_sp<SkData> {
        SkVertices_encode(self)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrRenderTargetContext {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkBaseDevice {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkDrawShadowRec {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkGlyphRunBuilder {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkSurface_Base {
    _unused: [u8; 0],
}
#[repr(C)]
pub struct SkCanvas__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
pub struct SkCanvas {
    pub vtable_: *const SkCanvas__bindgen_vtable,
    pub fMCStack: SkDeque,
    pub fMCRec: *mut SkCanvas_MCRec,
    pub fMCRecStorage: [isize; 512usize],
    pub fDeviceCMStorage: [isize; 28usize],
    pub fProps: SkSurfaceProps,
    pub fSaveCount: ::std::os::raw::c_int,
    pub fAllocator: u64,
    pub fSurfaceBase: *mut SkSurface_Base,
    pub fClipRestrictionRect: SkIRect,
    pub fIsScaleTranslate: bool,
    pub fDeviceClipBounds: SkRect,
    pub fAllowSoftClip: bool,
    pub fAllowSimplifyClip: bool,
    pub fScratchGlyphRunBuilder: u64,
}
pub const SkCanvas_PrivateSaveLayerFlags_kDontClipToLayer_PrivateSaveLayerFlag:
    SkCanvas_PrivateSaveLayerFlags = 2147483648;
pub type SkCanvas_PrivateSaveLayerFlags = u32;
pub const SkCanvas_SaveLayerFlagsSet_kInitWithPrevious_SaveLayerFlag: SkCanvas_SaveLayerFlagsSet =
    4;
pub const SkCanvas_SaveLayerFlagsSet_kMaskAgainstCoverage_EXPERIMENTAL_DONT_USE_SaveLayerFlag:
    SkCanvas_SaveLayerFlagsSet = 8;
pub const SkCanvas_SaveLayerFlagsSet_kF16ColorType: SkCanvas_SaveLayerFlagsSet = 16;
pub type SkCanvas_SaveLayerFlagsSet = u32;
pub type SkCanvas_SaveLayerFlags = u32;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkCanvas_SaveLayerRec {
    pub fBounds: *const SkRect,
    pub fPaint: *const SkPaint,
    pub fBackdrop: *const SkImageFilter,
    pub fClipMask: *const SkImage,
    pub fClipMatrix: *const SkMatrix,
    pub fSaveLayerFlags: SkCanvas_SaveLayerFlags,
}
#[test]
fn bindgen_test_layout_SkCanvas_SaveLayerRec() {
    assert_eq!(
        ::core::mem::size_of::<SkCanvas_SaveLayerRec>(),
        48usize,
        concat!("Size of: ", stringify!(SkCanvas_SaveLayerRec))
    );
    assert_eq!(
        ::core::mem::align_of::<SkCanvas_SaveLayerRec>(),
        8usize,
        concat!("Alignment of ", stringify!(SkCanvas_SaveLayerRec))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas_SaveLayerRec>())).fBounds as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_SaveLayerRec),
            "::",
            stringify!(fBounds)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas_SaveLayerRec>())).fPaint as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_SaveLayerRec),
            "::",
            stringify!(fPaint)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkCanvas_SaveLayerRec>())).fBackdrop as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_SaveLayerRec),
            "::",
            stringify!(fBackdrop)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkCanvas_SaveLayerRec>())).fClipMask as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_SaveLayerRec),
            "::",
            stringify!(fClipMask)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkCanvas_SaveLayerRec>())).fClipMatrix as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_SaveLayerRec),
            "::",
            stringify!(fClipMatrix)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkCanvas_SaveLayerRec>())).fSaveLayerFlags as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_SaveLayerRec),
            "::",
            stringify!(fSaveLayerFlags)
        )
    );
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkCanvas_PointMode {
    kPoints_PointMode = 0,
    kLines_PointMode = 1,
    kPolygon_PointMode = 2,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkCanvas_SrcRectConstraint {
    kStrict_SrcRectConstraint = 0,
    kFast_SrcRectConstraint = 1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkCanvas_Lattice {
    pub fXDivs: *const ::std::os::raw::c_int,
    pub fYDivs: *const ::std::os::raw::c_int,
    pub fRectTypes: *const SkCanvas_Lattice_RectType,
    pub fXCount: ::std::os::raw::c_int,
    pub fYCount: ::std::os::raw::c_int,
    pub fBounds: *const SkIRect,
    pub fColors: *const SkColor,
}
#[repr(u8)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkCanvas_Lattice_RectType {
    kDefault = 0,
    kTransparent = 1,
    kFixedColor = 2,
}
#[test]
fn bindgen_test_layout_SkCanvas_Lattice() {
    assert_eq!(
        ::core::mem::size_of::<SkCanvas_Lattice>(),
        48usize,
        concat!("Size of: ", stringify!(SkCanvas_Lattice))
    );
    assert_eq!(
        ::core::mem::align_of::<SkCanvas_Lattice>(),
        8usize,
        concat!("Alignment of ", stringify!(SkCanvas_Lattice))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas_Lattice>())).fXDivs as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_Lattice),
            "::",
            stringify!(fXDivs)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas_Lattice>())).fYDivs as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_Lattice),
            "::",
            stringify!(fYDivs)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas_Lattice>())).fRectTypes as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_Lattice),
            "::",
            stringify!(fRectTypes)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas_Lattice>())).fXCount as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_Lattice),
            "::",
            stringify!(fXCount)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas_Lattice>())).fYCount as *const _ as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_Lattice),
            "::",
            stringify!(fYCount)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas_Lattice>())).fBounds as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_Lattice),
            "::",
            stringify!(fBounds)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas_Lattice>())).fColors as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_Lattice),
            "::",
            stringify!(fColors)
        )
    );
}
pub const SkCanvas_QuadAAFlags_kLeft_QuadAAFlag: SkCanvas_QuadAAFlags = 1;
pub const SkCanvas_QuadAAFlags_kTop_QuadAAFlag: SkCanvas_QuadAAFlags = 2;
pub const SkCanvas_QuadAAFlags_kRight_QuadAAFlag: SkCanvas_QuadAAFlags = 4;
pub const SkCanvas_QuadAAFlags_kBottom_QuadAAFlag: SkCanvas_QuadAAFlags = 8;
pub const SkCanvas_QuadAAFlags_kNone_QuadAAFlags: SkCanvas_QuadAAFlags = 0;
pub const SkCanvas_QuadAAFlags_kAll_QuadAAFlags: SkCanvas_QuadAAFlags = 15;
pub type SkCanvas_QuadAAFlags = u32;
#[repr(C)]
pub struct SkCanvas_ImageSetEntry {
    pub fImage: sk_sp<SkImage>,
    pub fSrcRect: SkRect,
    pub fDstRect: SkRect,
    pub fMatrixIndex: ::std::os::raw::c_int,
    pub fAlpha: f32,
    pub fAAFlags: ::std::os::raw::c_uint,
    pub fHasClip: bool,
}
#[test]
fn bindgen_test_layout_SkCanvas_ImageSetEntry() {
    assert_eq!(
        ::core::mem::size_of::<SkCanvas_ImageSetEntry>(),
        56usize,
        concat!("Size of: ", stringify!(SkCanvas_ImageSetEntry))
    );
    assert_eq!(
        ::core::mem::align_of::<SkCanvas_ImageSetEntry>(),
        8usize,
        concat!("Alignment of ", stringify!(SkCanvas_ImageSetEntry))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas_ImageSetEntry>())).fImage as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_ImageSetEntry),
            "::",
            stringify!(fImage)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkCanvas_ImageSetEntry>())).fSrcRect as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_ImageSetEntry),
            "::",
            stringify!(fSrcRect)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkCanvas_ImageSetEntry>())).fDstRect as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_ImageSetEntry),
            "::",
            stringify!(fDstRect)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkCanvas_ImageSetEntry>())).fMatrixIndex as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_ImageSetEntry),
            "::",
            stringify!(fMatrixIndex)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas_ImageSetEntry>())).fAlpha as *const _ as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_ImageSetEntry),
            "::",
            stringify!(fAlpha)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkCanvas_ImageSetEntry>())).fAAFlags as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_ImageSetEntry),
            "::",
            stringify!(fAAFlags)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkCanvas_ImageSetEntry>())).fHasClip as *const _ as usize
        },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_ImageSetEntry),
            "::",
            stringify!(fHasClip)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas13ImageSetEntryC1E5sk_spIK7SkImageERK6SkRectS7_ifjb"]
    pub fn SkCanvas_ImageSetEntry_ImageSetEntry(
        this: *mut SkCanvas_ImageSetEntry,
        image: sk_sp<SkImage>,
        srcRect: *const SkRect,
        dstRect: *const SkRect,
        matrixIndex: ::std::os::raw::c_int,
        alpha: f32,
        aaFlags: ::std::os::raw::c_uint,
        hasClip: bool,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas13ImageSetEntryC1E5sk_spIK7SkImageERK6SkRectS7_fj"]
    pub fn SkCanvas_ImageSetEntry_ImageSetEntry1(
        this: *mut SkCanvas_ImageSetEntry,
        image: sk_sp<SkImage>,
        srcRect: *const SkRect,
        dstRect: *const SkRect,
        alpha: f32,
        aaFlags: ::std::os::raw::c_uint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas13ImageSetEntryC1Ev"]
    pub fn SkCanvas_ImageSetEntry_ImageSetEntry2(this: *mut SkCanvas_ImageSetEntry);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas13ImageSetEntryC1ERKS0_"]
    pub fn SkCanvas_ImageSetEntry_ImageSetEntry3(
        this: *mut SkCanvas_ImageSetEntry,
        arg1: *const SkCanvas_ImageSetEntry,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas13ImageSetEntryD1Ev"]
    pub fn SkCanvas_ImageSetEntry_ImageSetEntry_destructor(this: *mut SkCanvas_ImageSetEntry);
}
impl SkCanvas_ImageSetEntry {
    #[inline]
    pub unsafe fn new(
        image: sk_sp<SkImage>,
        srcRect: *const SkRect,
        dstRect: *const SkRect,
        matrixIndex: ::std::os::raw::c_int,
        alpha: f32,
        aaFlags: ::std::os::raw::c_uint,
        hasClip: bool,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkCanvas_ImageSetEntry_ImageSetEntry(
            &mut __bindgen_tmp,
            image,
            srcRect,
            dstRect,
            matrixIndex,
            alpha,
            aaFlags,
            hasClip,
        );
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(
        image: sk_sp<SkImage>,
        srcRect: *const SkRect,
        dstRect: *const SkRect,
        alpha: f32,
        aaFlags: ::std::os::raw::c_uint,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkCanvas_ImageSetEntry_ImageSetEntry1(
            &mut __bindgen_tmp,
            image,
            srcRect,
            dstRect,
            alpha,
            aaFlags,
        );
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new2() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkCanvas_ImageSetEntry_ImageSetEntry2(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new3(arg1: *const SkCanvas_ImageSetEntry) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkCanvas_ImageSetEntry_ImageSetEntry3(&mut __bindgen_tmp, arg1);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        SkCanvas_ImageSetEntry_ImageSetEntry_destructor(self)
    }
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkCanvas_SaveLayerStrategy {
    kFullLayer_SaveLayerStrategy = 0,
    kNoLayer_SaveLayerStrategy = 1,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkCanvas_ClipEdgeStyle {
    kHard_ClipEdgeStyle = 0,
    kSoft_ClipEdgeStyle = 1,
}
#[repr(C)]
pub struct SkCanvas_LayerIter {
    pub fStorage: [isize; 32usize],
    pub fImpl: *mut SkDrawIter,
    pub fDefaultPaint: SkPaint,
    pub fDone: bool,
}
#[test]
fn bindgen_test_layout_SkCanvas_LayerIter() {
    assert_eq!(
        ::core::mem::size_of::<SkCanvas_LayerIter>(),
        352usize,
        concat!("Size of: ", stringify!(SkCanvas_LayerIter))
    );
    assert_eq!(
        ::core::mem::align_of::<SkCanvas_LayerIter>(),
        8usize,
        concat!("Alignment of ", stringify!(SkCanvas_LayerIter))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas_LayerIter>())).fStorage as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_LayerIter),
            "::",
            stringify!(fStorage)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas_LayerIter>())).fImpl as *const _ as usize },
        256usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_LayerIter),
            "::",
            stringify!(fImpl)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkCanvas_LayerIter>())).fDefaultPaint as *const _ as usize
        },
        264usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_LayerIter),
            "::",
            stringify!(fDefaultPaint)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas_LayerIter>())).fDone as *const _ as usize },
        344usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_LayerIter),
            "::",
            stringify!(fDone)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas9LayerIter4nextEv"]
    pub fn SkCanvas_LayerIter_next(this: *mut SkCanvas_LayerIter);
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas9LayerIter6deviceEv"]
    pub fn SkCanvas_LayerIter_device(this: *const SkCanvas_LayerIter) -> *mut SkBaseDevice;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas9LayerIter6matrixEv"]
    pub fn SkCanvas_LayerIter_matrix(this: *const SkCanvas_LayerIter) -> *const SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas9LayerIter10clipBoundsEv"]
    pub fn SkCanvas_LayerIter_clipBounds(this: *const SkCanvas_LayerIter) -> SkIRect;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas9LayerIter5paintEv"]
    pub fn SkCanvas_LayerIter_paint(this: *const SkCanvas_LayerIter) -> *const SkPaint;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas9LayerIter1xEv"]
    pub fn SkCanvas_LayerIter_x(this: *const SkCanvas_LayerIter) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas9LayerIter1yEv"]
    pub fn SkCanvas_LayerIter_y(this: *const SkCanvas_LayerIter) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas9LayerIterC1EPS_"]
    pub fn SkCanvas_LayerIter_LayerIter(this: *mut SkCanvas_LayerIter, arg1: *mut SkCanvas);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas9LayerIterD1Ev"]
    pub fn SkCanvas_LayerIter_LayerIter_destructor(this: *mut SkCanvas_LayerIter);
}
impl SkCanvas_LayerIter {
    #[inline]
    pub unsafe fn next(&mut self) {
        SkCanvas_LayerIter_next(self)
    }
    #[inline]
    pub unsafe fn device(&self) -> *mut SkBaseDevice {
        SkCanvas_LayerIter_device(self)
    }
    #[inline]
    pub unsafe fn matrix(&self) -> *const SkMatrix {
        SkCanvas_LayerIter_matrix(self)
    }
    #[inline]
    pub unsafe fn clipBounds(&self) -> SkIRect {
        SkCanvas_LayerIter_clipBounds(self)
    }
    #[inline]
    pub unsafe fn paint(&self) -> *const SkPaint {
        SkCanvas_LayerIter_paint(self)
    }
    #[inline]
    pub unsafe fn x(&self) -> ::std::os::raw::c_int {
        SkCanvas_LayerIter_x(self)
    }
    #[inline]
    pub unsafe fn y(&self) -> ::std::os::raw::c_int {
        SkCanvas_LayerIter_y(self)
    }
    #[inline]
    pub unsafe fn new(arg1: *mut SkCanvas) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkCanvas_LayerIter_LayerIter(&mut __bindgen_tmp, arg1);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        SkCanvas_LayerIter_LayerIter_destructor(self)
    }
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkCanvas_ShaderOverrideOpacity {
    kNone_ShaderOverrideOpacity = 0,
    kOpaque_ShaderOverrideOpacity = 1,
    kNotOpaque_ShaderOverrideOpacity = 2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkCanvas_MCRec {
    _unused: [u8; 0],
}
#[repr(C)]
pub struct SkCanvas_AutoValidateClip {
    pub fCanvas: *const SkCanvas,
}
#[test]
fn bindgen_test_layout_SkCanvas_AutoValidateClip() {
    assert_eq!(
        ::core::mem::size_of::<SkCanvas_AutoValidateClip>(),
        8usize,
        concat!("Size of: ", stringify!(SkCanvas_AutoValidateClip))
    );
    assert_eq!(
        ::core::mem::align_of::<SkCanvas_AutoValidateClip>(),
        8usize,
        concat!("Alignment of ", stringify!(SkCanvas_AutoValidateClip))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkCanvas_AutoValidateClip>())).fCanvas as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas_AutoValidateClip),
            "::",
            stringify!(fCanvas)
        )
    );
}
pub type SkCanvas_INHERITED = SkRefCnt;
pub const SkCanvas_kMCRecSize: ::std::os::raw::c_int = 128;
pub const SkCanvas_kMCRecCount: ::std::os::raw::c_int = 32;
pub const SkCanvas_kDeviceCMSize: ::std::os::raw::c_int = 224;
#[test]
fn bindgen_test_layout_SkCanvas() {
    assert_eq!(
        ::core::mem::size_of::<SkCanvas>(),
        4472usize,
        concat!("Size of: ", stringify!(SkCanvas))
    );
    assert_eq!(
        ::core::mem::align_of::<SkCanvas>(),
        8usize,
        concat!("Alignment of ", stringify!(SkCanvas))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas>())).fMCStack as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas),
            "::",
            stringify!(fMCStack)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas>())).fMCRec as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas),
            "::",
            stringify!(fMCRec)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas>())).fMCRecStorage as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas),
            "::",
            stringify!(fMCRecStorage)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas>())).fDeviceCMStorage as *const _ as usize },
        4168usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas),
            "::",
            stringify!(fDeviceCMStorage)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas>())).fProps as *const _ as usize },
        4392usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas),
            "::",
            stringify!(fProps)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas>())).fSaveCount as *const _ as usize },
        4400usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas),
            "::",
            stringify!(fSaveCount)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas>())).fAllocator as *const _ as usize },
        4408usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas),
            "::",
            stringify!(fAllocator)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas>())).fSurfaceBase as *const _ as usize },
        4416usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas),
            "::",
            stringify!(fSurfaceBase)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas>())).fClipRestrictionRect as *const _ as usize },
        4424usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas),
            "::",
            stringify!(fClipRestrictionRect)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas>())).fIsScaleTranslate as *const _ as usize },
        4440usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas),
            "::",
            stringify!(fIsScaleTranslate)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas>())).fDeviceClipBounds as *const _ as usize },
        4444usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas),
            "::",
            stringify!(fDeviceClipBounds)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas>())).fAllowSoftClip as *const _ as usize },
        4460usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas),
            "::",
            stringify!(fAllowSoftClip)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCanvas>())).fAllowSimplifyClip as *const _ as usize },
        4461usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas),
            "::",
            stringify!(fAllowSimplifyClip)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkCanvas>())).fScratchGlyphRunBuilder as *const _ as usize
        },
        4464usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCanvas),
            "::",
            stringify!(fScratchGlyphRunBuilder)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas16MakeRasterDirectERK11SkImageInfoPvmPK14SkSurfaceProps"]
    pub fn SkCanvas_MakeRasterDirect(
        info: *const SkImageInfo,
        pixels: *mut ::std::os::raw::c_void,
        rowBytes: usize,
        props: *const SkSurfaceProps,
    ) -> u64;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas9imageInfoEv"]
    pub fn SkCanvas_imageInfo(this: *const SkCanvas) -> SkImageInfo;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas8getPropsEP14SkSurfaceProps"]
    pub fn SkCanvas_getProps(this: *const SkCanvas, props: *mut SkSurfaceProps) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas5flushEv"]
    pub fn SkCanvas_flush(this: *mut SkCanvas);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas11makeSurfaceERK11SkImageInfoPK14SkSurfaceProps"]
    pub fn SkCanvas_makeSurface(
        this: *mut SkCanvas,
        info: *const SkImageInfo,
        props: *const SkSurfaceProps,
    ) -> sk_sp<SkSurface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas20accessTopLayerPixelsEP11SkImageInfoPmP8SkIPoint"]
    pub fn SkCanvas_accessTopLayerPixels(
        this: *mut SkCanvas,
        info: *mut SkImageInfo,
        rowBytes: *mut usize,
        origin: *mut SkIPoint,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas21accessTopRasterHandleEv"]
    pub fn SkCanvas_accessTopRasterHandle(this: *const SkCanvas) -> SkRasterHandleAllocator_Handle;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas10peekPixelsEP8SkPixmap"]
    pub fn SkCanvas_peekPixels(this: *mut SkCanvas, pixmap: *mut SkPixmap) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas10readPixelsERK11SkImageInfoPvmii"]
    pub fn SkCanvas_readPixels(
        this: *mut SkCanvas,
        dstInfo: *const SkImageInfo,
        dstPixels: *mut ::std::os::raw::c_void,
        dstRowBytes: usize,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas10readPixelsERK8SkPixmapii"]
    pub fn SkCanvas_readPixels1(
        this: *mut SkCanvas,
        pixmap: *const SkPixmap,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas10readPixelsERK8SkBitmapii"]
    pub fn SkCanvas_readPixels2(
        this: *mut SkCanvas,
        bitmap: *const SkBitmap,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas11writePixelsERK11SkImageInfoPKvmii"]
    pub fn SkCanvas_writePixels(
        this: *mut SkCanvas,
        info: *const SkImageInfo,
        pixels: *const ::std::os::raw::c_void,
        rowBytes: usize,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas11writePixelsERK8SkBitmapii"]
    pub fn SkCanvas_writePixels1(
        this: *mut SkCanvas,
        bitmap: *const SkBitmap,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas4saveEv"]
    pub fn SkCanvas_save(this: *mut SkCanvas) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas9saveLayerEPK6SkRectPK7SkPaint"]
    pub fn SkCanvas_saveLayer(
        this: *mut SkCanvas,
        bounds: *const SkRect,
        paint: *const SkPaint,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas14saveLayerAlphaEPK6SkRectj"]
    pub fn SkCanvas_saveLayerAlpha(
        this: *mut SkCanvas,
        bounds: *const SkRect,
        alpha: U8CPU,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas9saveLayerERKNS_12SaveLayerRecE"]
    pub fn SkCanvas_saveLayer1(
        this: *mut SkCanvas,
        layerRec: *const SkCanvas_SaveLayerRec,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas7restoreEv"]
    pub fn SkCanvas_restore(this: *mut SkCanvas);
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas12getSaveCountEv"]
    pub fn SkCanvas_getSaveCount(this: *const SkCanvas) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas14restoreToCountEi"]
    pub fn SkCanvas_restoreToCount(this: *mut SkCanvas, saveCount: ::std::os::raw::c_int);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas9translateEff"]
    pub fn SkCanvas_translate(this: *mut SkCanvas, dx: SkScalar, dy: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas5scaleEff"]
    pub fn SkCanvas_scale(this: *mut SkCanvas, sx: SkScalar, sy: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas6rotateEf"]
    pub fn SkCanvas_rotate(this: *mut SkCanvas, degrees: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas6rotateEfff"]
    pub fn SkCanvas_rotate1(this: *mut SkCanvas, degrees: SkScalar, px: SkScalar, py: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas4skewEff"]
    pub fn SkCanvas_skew(this: *mut SkCanvas, sx: SkScalar, sy: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas6concatERK8SkMatrix"]
    pub fn SkCanvas_concat(this: *mut SkCanvas, matrix: *const SkMatrix);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas9setMatrixERK8SkMatrix"]
    pub fn SkCanvas_setMatrix(this: *mut SkCanvas, matrix: *const SkMatrix);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas11resetMatrixEv"]
    pub fn SkCanvas_resetMatrix(this: *mut SkCanvas);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas8clipRectERK6SkRect8SkClipOpb"]
    pub fn SkCanvas_clipRect(
        this: *mut SkCanvas,
        rect: *const SkRect,
        op: SkClipOp,
        doAntiAlias: bool,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas41androidFramework_setDeviceClipRestrictionERK7SkIRect"]
    pub fn SkCanvas_androidFramework_setDeviceClipRestriction(
        this: *mut SkCanvas,
        rect: *const SkIRect,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas9clipRRectERK7SkRRect8SkClipOpb"]
    pub fn SkCanvas_clipRRect(
        this: *mut SkCanvas,
        rrect: *const SkRRect,
        op: SkClipOp,
        doAntiAlias: bool,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas8clipPathERK6SkPath8SkClipOpb"]
    pub fn SkCanvas_clipPath(
        this: *mut SkCanvas,
        path: *const SkPath,
        op: SkClipOp,
        doAntiAlias: bool,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas10clipRegionERK8SkRegion8SkClipOp"]
    pub fn SkCanvas_clipRegion(this: *mut SkCanvas, deviceRgn: *const SkRegion, op: SkClipOp);
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas11quickRejectERK6SkRect"]
    pub fn SkCanvas_quickReject(this: *const SkCanvas, rect: *const SkRect) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas11quickRejectERK6SkPath"]
    pub fn SkCanvas_quickReject1(this: *const SkCanvas, path: *const SkPath) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas18getLocalClipBoundsEv"]
    pub fn SkCanvas_getLocalClipBounds(this: *const SkCanvas) -> SkRect;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas19getDeviceClipBoundsEv"]
    pub fn SkCanvas_getDeviceClipBounds(this: *const SkCanvas) -> SkIRect;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas9drawColorEj11SkBlendMode"]
    pub fn SkCanvas_drawColor(this: *mut SkCanvas, color: SkColor, mode: SkBlendMode);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas9drawPaintERK7SkPaint"]
    pub fn SkCanvas_drawPaint(this: *mut SkCanvas, paint: *const SkPaint);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas10drawPointsENS_9PointModeEmPK7SkPointRK7SkPaint"]
    pub fn SkCanvas_drawPoints(
        this: *mut SkCanvas,
        mode: SkCanvas_PointMode,
        count: usize,
        pts: *const SkPoint,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas9drawPointEffRK7SkPaint"]
    pub fn SkCanvas_drawPoint(this: *mut SkCanvas, x: SkScalar, y: SkScalar, paint: *const SkPaint);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas8drawLineEffffRK7SkPaint"]
    pub fn SkCanvas_drawLine(
        this: *mut SkCanvas,
        x0: SkScalar,
        y0: SkScalar,
        x1: SkScalar,
        y1: SkScalar,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas8drawRectERK6SkRectRK7SkPaint"]
    pub fn SkCanvas_drawRect(this: *mut SkCanvas, rect: *const SkRect, paint: *const SkPaint);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas10drawRegionERK8SkRegionRK7SkPaint"]
    pub fn SkCanvas_drawRegion(this: *mut SkCanvas, region: *const SkRegion, paint: *const SkPaint);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas8drawOvalERK6SkRectRK7SkPaint"]
    pub fn SkCanvas_drawOval(this: *mut SkCanvas, oval: *const SkRect, paint: *const SkPaint);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas9drawRRectERK7SkRRectRK7SkPaint"]
    pub fn SkCanvas_drawRRect(this: *mut SkCanvas, rrect: *const SkRRect, paint: *const SkPaint);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas10drawDRRectERK7SkRRectS2_RK7SkPaint"]
    pub fn SkCanvas_drawDRRect(
        this: *mut SkCanvas,
        outer: *const SkRRect,
        inner: *const SkRRect,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas10drawCircleEfffRK7SkPaint"]
    pub fn SkCanvas_drawCircle(
        this: *mut SkCanvas,
        cx: SkScalar,
        cy: SkScalar,
        radius: SkScalar,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas7drawArcERK6SkRectffbRK7SkPaint"]
    pub fn SkCanvas_drawArc(
        this: *mut SkCanvas,
        oval: *const SkRect,
        startAngle: SkScalar,
        sweepAngle: SkScalar,
        useCenter: bool,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas13drawRoundRectERK6SkRectffRK7SkPaint"]
    pub fn SkCanvas_drawRoundRect(
        this: *mut SkCanvas,
        rect: *const SkRect,
        rx: SkScalar,
        ry: SkScalar,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas8drawPathERK6SkPathRK7SkPaint"]
    pub fn SkCanvas_drawPath(this: *mut SkCanvas, path: *const SkPath, paint: *const SkPaint);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas9drawImageEPK7SkImageffPK7SkPaint"]
    pub fn SkCanvas_drawImage(
        this: *mut SkCanvas,
        image: *const SkImage,
        left: SkScalar,
        top: SkScalar,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas13drawImageRectEPK7SkImageRK6SkRectS5_PK7SkPaintNS_17SrcRectConstraintE"]
    pub fn SkCanvas_drawImageRect(
        this: *mut SkCanvas,
        image: *const SkImage,
        src: *const SkRect,
        dst: *const SkRect,
        paint: *const SkPaint,
        constraint: SkCanvas_SrcRectConstraint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas13drawImageRectEPK7SkImageRK7SkIRectRK6SkRectPK7SkPaintNS_17SrcRectConstraintE"]
    pub fn SkCanvas_drawImageRect1(
        this: *mut SkCanvas,
        image: *const SkImage,
        isrc: *const SkIRect,
        dst: *const SkRect,
        paint: *const SkPaint,
        constraint: SkCanvas_SrcRectConstraint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas13drawImageRectEPK7SkImageRK6SkRectPK7SkPaint"]
    pub fn SkCanvas_drawImageRect2(
        this: *mut SkCanvas,
        image: *const SkImage,
        dst: *const SkRect,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas13drawImageNineEPK7SkImageRK7SkIRectRK6SkRectPK7SkPaint"]
    pub fn SkCanvas_drawImageNine(
        this: *mut SkCanvas,
        image: *const SkImage,
        center: *const SkIRect,
        dst: *const SkRect,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas10drawBitmapERK8SkBitmapffPK7SkPaint"]
    pub fn SkCanvas_drawBitmap(
        this: *mut SkCanvas,
        bitmap: *const SkBitmap,
        left: SkScalar,
        top: SkScalar,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas14drawBitmapRectERK8SkBitmapRK6SkRectS5_PK7SkPaintNS_17SrcRectConstraintE"]
    pub fn SkCanvas_drawBitmapRect(
        this: *mut SkCanvas,
        bitmap: *const SkBitmap,
        src: *const SkRect,
        dst: *const SkRect,
        paint: *const SkPaint,
        constraint: SkCanvas_SrcRectConstraint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas14drawBitmapRectERK8SkBitmapRK7SkIRectRK6SkRectPK7SkPaintNS_17SrcRectConstraintE"]
    pub fn SkCanvas_drawBitmapRect1(
        this: *mut SkCanvas,
        bitmap: *const SkBitmap,
        isrc: *const SkIRect,
        dst: *const SkRect,
        paint: *const SkPaint,
        constraint: SkCanvas_SrcRectConstraint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas14drawBitmapRectERK8SkBitmapRK6SkRectPK7SkPaintNS_17SrcRectConstraintE"]
    pub fn SkCanvas_drawBitmapRect2(
        this: *mut SkCanvas,
        bitmap: *const SkBitmap,
        dst: *const SkRect,
        paint: *const SkPaint,
        constraint: SkCanvas_SrcRectConstraint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas14drawBitmapNineERK8SkBitmapRK7SkIRectRK6SkRectPK7SkPaint"]
    pub fn SkCanvas_drawBitmapNine(
        this: *mut SkCanvas,
        bitmap: *const SkBitmap,
        center: *const SkIRect,
        dst: *const SkRect,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas17drawBitmapLatticeERK8SkBitmapRKNS_7LatticeERK6SkRectPK7SkPaint"]
    pub fn SkCanvas_drawBitmapLattice(
        this: *mut SkCanvas,
        bitmap: *const SkBitmap,
        lattice: *const SkCanvas_Lattice,
        dst: *const SkRect,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas16drawImageLatticeEPK7SkImageRKNS_7LatticeERK6SkRectPK7SkPaint"]
    pub fn SkCanvas_drawImageLattice(
        this: *mut SkCanvas,
        image: *const SkImage,
        lattice: *const SkCanvas_Lattice,
        dst: *const SkRect,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas27experimental_DrawEdgeAAQuadERK6SkRectPK7SkPointNS_11QuadAAFlagsEj11SkBlendMode"]
    pub fn SkCanvas_experimental_DrawEdgeAAQuad(
        this: *mut SkCanvas,
        rect: *const SkRect,
        clip: *const SkPoint,
        aaFlags: SkCanvas_QuadAAFlags,
        color: SkColor,
        mode: SkBlendMode,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas31experimental_DrawEdgeAAImageSetEPKNS_13ImageSetEntryEiPK7SkPointPK8SkMatrixPK7SkPaintNS_17SrcRectConstraintE"]
    pub fn SkCanvas_experimental_DrawEdgeAAImageSet(
        this: *mut SkCanvas,
        imageSet: *const SkCanvas_ImageSetEntry,
        cnt: ::std::os::raw::c_int,
        dstClips: *const SkPoint,
        preViewMatrices: *const SkMatrix,
        paint: *const SkPaint,
        constraint: SkCanvas_SrcRectConstraint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas14drawSimpleTextEPKvm14SkTextEncodingffRK6SkFontRK7SkPaint"]
    pub fn SkCanvas_drawSimpleText(
        this: *mut SkCanvas,
        text: *const ::std::os::raw::c_void,
        byteLength: usize,
        encoding: SkTextEncoding,
        x: SkScalar,
        y: SkScalar,
        font: *const SkFont,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas12drawTextBlobEPK10SkTextBlobffRK7SkPaint"]
    pub fn SkCanvas_drawTextBlob(
        this: *mut SkCanvas,
        blob: *const SkTextBlob,
        x: SkScalar,
        y: SkScalar,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas11drawPictureEPK9SkPicturePK8SkMatrixPK7SkPaint"]
    pub fn SkCanvas_drawPicture(
        this: *mut SkCanvas,
        picture: *const SkPicture,
        matrix: *const SkMatrix,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas12drawVerticesEPK10SkVertices11SkBlendModeRK7SkPaint"]
    pub fn SkCanvas_drawVertices(
        this: *mut SkCanvas,
        vertices: *const SkVertices,
        mode: SkBlendMode,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas12drawVerticesERK5sk_spI10SkVerticesE11SkBlendModeRK7SkPaint"]
    pub fn SkCanvas_drawVertices1(
        this: *mut SkCanvas,
        vertices: *const sk_sp<SkVertices>,
        mode: SkBlendMode,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas12drawVerticesEPK10SkVerticesPKNS0_4BoneEi11SkBlendModeRK7SkPaint"]
    pub fn SkCanvas_drawVertices2(
        this: *mut SkCanvas,
        vertices: *const SkVertices,
        bones: *const SkVertices_Bone,
        boneCount: ::std::os::raw::c_int,
        mode: SkBlendMode,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas12drawVerticesERK5sk_spI10SkVerticesEPKNS1_4BoneEi11SkBlendModeRK7SkPaint"]
    pub fn SkCanvas_drawVertices3(
        this: *mut SkCanvas,
        vertices: *const sk_sp<SkVertices>,
        bones: *const SkVertices_Bone,
        boneCount: ::std::os::raw::c_int,
        mode: SkBlendMode,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas9drawPatchEPK7SkPointPKjS2_11SkBlendModeRK7SkPaint"]
    pub fn SkCanvas_drawPatch(
        this: *mut SkCanvas,
        cubics: *const SkPoint,
        colors: *const SkColor,
        texCoords: *const SkPoint,
        mode: SkBlendMode,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas9drawAtlasEPK7SkImagePK9SkRSXformPK6SkRectPKji11SkBlendModeS8_PK7SkPaint"]
    pub fn SkCanvas_drawAtlas(
        this: *mut SkCanvas,
        atlas: *const SkImage,
        xform: *const SkRSXform,
        tex: *const SkRect,
        colors: *const SkColor,
        count: ::std::os::raw::c_int,
        mode: SkBlendMode,
        cullRect: *const SkRect,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas12drawDrawableEP10SkDrawablePK8SkMatrix"]
    pub fn SkCanvas_drawDrawable(
        this: *mut SkCanvas,
        drawable: *mut SkDrawable,
        matrix: *const SkMatrix,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas12drawDrawableEP10SkDrawableff"]
    pub fn SkCanvas_drawDrawable1(
        this: *mut SkCanvas,
        drawable: *mut SkDrawable,
        x: SkScalar,
        y: SkScalar,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas14drawAnnotationERK6SkRectPKcP6SkData"]
    pub fn SkCanvas_drawAnnotation(
        this: *mut SkCanvas,
        rect: *const SkRect,
        key: *const ::std::os::raw::c_char,
        value: *mut SkData,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas14getTotalMatrixEv"]
    pub fn SkCanvas_getTotalMatrix(this: *const SkCanvas) -> *const SkMatrix;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas20legacy_drawImageRectEPK7SkImagePK6SkRectRS4_PK7SkPaintNS_17SrcRectConstraintE"]
    pub fn SkCanvas_legacy_drawImageRect(
        this: *mut SkCanvas,
        image: *const SkImage,
        src: *const SkRect,
        dst: *const SkRect,
        paint: *const SkPaint,
        constraint: SkCanvas_SrcRectConstraint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas21legacy_drawBitmapRectERK8SkBitmapPK6SkRectRS4_PK7SkPaintNS_17SrcRectConstraintE"]
    pub fn SkCanvas_legacy_drawBitmapRect(
        this: *mut SkCanvas,
        bitmap: *const SkBitmap,
        src: *const SkRect,
        dst: *const SkRect,
        paint: *const SkPaint,
        constraint: SkCanvas_SrcRectConstraint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas29temporary_internal_getRgnClipEP8SkRegion"]
    pub fn SkCanvas_temporary_internal_getRgnClip(this: *mut SkCanvas, region: *mut SkRegion);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas23private_draw_shadow_recERK6SkPathRK15SkDrawShadowRec"]
    pub fn SkCanvas_private_draw_shadow_rec(
        this: *mut SkCanvas,
        arg1: *const SkPath,
        arg2: *const SkDrawShadowRec,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas14clipRectBoundsEPK6SkRectjP7SkIRectPK13SkImageFilter"]
    pub fn SkCanvas_clipRectBounds(
        this: *mut SkCanvas,
        bounds: *const SkRect,
        flags: SkCanvas_SaveLayerFlags,
        intersection: *mut SkIRect,
        imageFilter: *const SkImageFilter,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas12getTopDeviceEv"]
    pub fn SkCanvas_getTopDevice(this: *const SkCanvas) -> *mut SkBaseDevice;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvasC1Ev"]
    pub fn SkCanvas_SkCanvas(this: *mut SkCanvas);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvasC1EiiPK14SkSurfaceProps"]
    pub fn SkCanvas_SkCanvas1(
        this: *mut SkCanvas,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        props: *const SkSurfaceProps,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvasC1E5sk_spI12SkBaseDeviceE"]
    pub fn SkCanvas_SkCanvas2(this: *mut SkCanvas, device: sk_sp<SkBaseDevice>);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvasC1ERK8SkBitmap"]
    pub fn SkCanvas_SkCanvas3(this: *mut SkCanvas, bitmap: *const SkBitmap);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvasC1ERK8SkBitmapRK14SkSurfaceProps"]
    pub fn SkCanvas_SkCanvas4(
        this: *mut SkCanvas,
        bitmap: *const SkBitmap,
        props: *const SkSurfaceProps,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvasC1ERK7SkIRect"]
    pub fn SkCanvas_SkCanvas5(this: *mut SkCanvas, bounds: *const SkIRect);
}
impl SkCanvas {
    #[inline]
    pub unsafe fn MakeRasterDirect(
        info: *const SkImageInfo,
        pixels: *mut ::std::os::raw::c_void,
        rowBytes: usize,
        props: *const SkSurfaceProps,
    ) -> u64 {
        SkCanvas_MakeRasterDirect(info, pixels, rowBytes, props)
    }
    #[inline]
    pub unsafe fn imageInfo(&self) -> SkImageInfo {
        SkCanvas_imageInfo(self)
    }
    #[inline]
    pub unsafe fn getProps(&self, props: *mut SkSurfaceProps) -> bool {
        SkCanvas_getProps(self, props)
    }
    #[inline]
    pub unsafe fn flush(&mut self) {
        SkCanvas_flush(self)
    }
    #[inline]
    pub unsafe fn makeSurface(
        &mut self,
        info: *const SkImageInfo,
        props: *const SkSurfaceProps,
    ) -> sk_sp<SkSurface> {
        SkCanvas_makeSurface(self, info, props)
    }
    #[inline]
    pub unsafe fn accessTopLayerPixels(
        &mut self,
        info: *mut SkImageInfo,
        rowBytes: *mut usize,
        origin: *mut SkIPoint,
    ) -> *mut ::std::os::raw::c_void {
        SkCanvas_accessTopLayerPixels(self, info, rowBytes, origin)
    }
    #[inline]
    pub unsafe fn accessTopRasterHandle(&self) -> SkRasterHandleAllocator_Handle {
        SkCanvas_accessTopRasterHandle(self)
    }
    #[inline]
    pub unsafe fn peekPixels(&mut self, pixmap: *mut SkPixmap) -> bool {
        SkCanvas_peekPixels(self, pixmap)
    }
    #[inline]
    pub unsafe fn readPixels(
        &mut self,
        dstInfo: *const SkImageInfo,
        dstPixels: *mut ::std::os::raw::c_void,
        dstRowBytes: usize,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
    ) -> bool {
        SkCanvas_readPixels(self, dstInfo, dstPixels, dstRowBytes, srcX, srcY)
    }
    #[inline]
    pub unsafe fn readPixels1(
        &mut self,
        pixmap: *const SkPixmap,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
    ) -> bool {
        SkCanvas_readPixels1(self, pixmap, srcX, srcY)
    }
    #[inline]
    pub unsafe fn readPixels2(
        &mut self,
        bitmap: *const SkBitmap,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
    ) -> bool {
        SkCanvas_readPixels2(self, bitmap, srcX, srcY)
    }
    #[inline]
    pub unsafe fn writePixels(
        &mut self,
        info: *const SkImageInfo,
        pixels: *const ::std::os::raw::c_void,
        rowBytes: usize,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
    ) -> bool {
        SkCanvas_writePixels(self, info, pixels, rowBytes, x, y)
    }
    #[inline]
    pub unsafe fn writePixels1(
        &mut self,
        bitmap: *const SkBitmap,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
    ) -> bool {
        SkCanvas_writePixels1(self, bitmap, x, y)
    }
    #[inline]
    pub unsafe fn save(&mut self) -> ::std::os::raw::c_int {
        SkCanvas_save(self)
    }
    #[inline]
    pub unsafe fn saveLayer(
        &mut self,
        bounds: *const SkRect,
        paint: *const SkPaint,
    ) -> ::std::os::raw::c_int {
        SkCanvas_saveLayer(self, bounds, paint)
    }
    #[inline]
    pub unsafe fn saveLayerAlpha(
        &mut self,
        bounds: *const SkRect,
        alpha: U8CPU,
    ) -> ::std::os::raw::c_int {
        SkCanvas_saveLayerAlpha(self, bounds, alpha)
    }
    #[inline]
    pub unsafe fn saveLayer1(
        &mut self,
        layerRec: *const SkCanvas_SaveLayerRec,
    ) -> ::std::os::raw::c_int {
        SkCanvas_saveLayer1(self, layerRec)
    }
    #[inline]
    pub unsafe fn restore(&mut self) {
        SkCanvas_restore(self)
    }
    #[inline]
    pub unsafe fn getSaveCount(&self) -> ::std::os::raw::c_int {
        SkCanvas_getSaveCount(self)
    }
    #[inline]
    pub unsafe fn restoreToCount(&mut self, saveCount: ::std::os::raw::c_int) {
        SkCanvas_restoreToCount(self, saveCount)
    }
    #[inline]
    pub unsafe fn translate(&mut self, dx: SkScalar, dy: SkScalar) {
        SkCanvas_translate(self, dx, dy)
    }
    #[inline]
    pub unsafe fn scale(&mut self, sx: SkScalar, sy: SkScalar) {
        SkCanvas_scale(self, sx, sy)
    }
    #[inline]
    pub unsafe fn rotate(&mut self, degrees: SkScalar) {
        SkCanvas_rotate(self, degrees)
    }
    #[inline]
    pub unsafe fn rotate1(&mut self, degrees: SkScalar, px: SkScalar, py: SkScalar) {
        SkCanvas_rotate1(self, degrees, px, py)
    }
    #[inline]
    pub unsafe fn skew(&mut self, sx: SkScalar, sy: SkScalar) {
        SkCanvas_skew(self, sx, sy)
    }
    #[inline]
    pub unsafe fn concat(&mut self, matrix: *const SkMatrix) {
        SkCanvas_concat(self, matrix)
    }
    #[inline]
    pub unsafe fn setMatrix(&mut self, matrix: *const SkMatrix) {
        SkCanvas_setMatrix(self, matrix)
    }
    #[inline]
    pub unsafe fn resetMatrix(&mut self) {
        SkCanvas_resetMatrix(self)
    }
    #[inline]
    pub unsafe fn clipRect(&mut self, rect: *const SkRect, op: SkClipOp, doAntiAlias: bool) {
        SkCanvas_clipRect(self, rect, op, doAntiAlias)
    }
    #[inline]
    pub unsafe fn androidFramework_setDeviceClipRestriction(&mut self, rect: *const SkIRect) {
        SkCanvas_androidFramework_setDeviceClipRestriction(self, rect)
    }
    #[inline]
    pub unsafe fn clipRRect(&mut self, rrect: *const SkRRect, op: SkClipOp, doAntiAlias: bool) {
        SkCanvas_clipRRect(self, rrect, op, doAntiAlias)
    }
    #[inline]
    pub unsafe fn clipPath(&mut self, path: *const SkPath, op: SkClipOp, doAntiAlias: bool) {
        SkCanvas_clipPath(self, path, op, doAntiAlias)
    }
    #[inline]
    pub unsafe fn clipRegion(&mut self, deviceRgn: *const SkRegion, op: SkClipOp) {
        SkCanvas_clipRegion(self, deviceRgn, op)
    }
    #[inline]
    pub unsafe fn quickReject(&self, rect: *const SkRect) -> bool {
        SkCanvas_quickReject(self, rect)
    }
    #[inline]
    pub unsafe fn quickReject1(&self, path: *const SkPath) -> bool {
        SkCanvas_quickReject1(self, path)
    }
    #[inline]
    pub unsafe fn getLocalClipBounds(&self) -> SkRect {
        SkCanvas_getLocalClipBounds(self)
    }
    #[inline]
    pub unsafe fn getDeviceClipBounds(&self) -> SkIRect {
        SkCanvas_getDeviceClipBounds(self)
    }
    #[inline]
    pub unsafe fn drawColor(&mut self, color: SkColor, mode: SkBlendMode) {
        SkCanvas_drawColor(self, color, mode)
    }
    #[inline]
    pub unsafe fn drawPaint(&mut self, paint: *const SkPaint) {
        SkCanvas_drawPaint(self, paint)
    }
    #[inline]
    pub unsafe fn drawPoints(
        &mut self,
        mode: SkCanvas_PointMode,
        count: usize,
        pts: *const SkPoint,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawPoints(self, mode, count, pts, paint)
    }
    #[inline]
    pub unsafe fn drawPoint(&mut self, x: SkScalar, y: SkScalar, paint: *const SkPaint) {
        SkCanvas_drawPoint(self, x, y, paint)
    }
    #[inline]
    pub unsafe fn drawLine(
        &mut self,
        x0: SkScalar,
        y0: SkScalar,
        x1: SkScalar,
        y1: SkScalar,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawLine(self, x0, y0, x1, y1, paint)
    }
    #[inline]
    pub unsafe fn drawRect(&mut self, rect: *const SkRect, paint: *const SkPaint) {
        SkCanvas_drawRect(self, rect, paint)
    }
    #[inline]
    pub unsafe fn drawRegion(&mut self, region: *const SkRegion, paint: *const SkPaint) {
        SkCanvas_drawRegion(self, region, paint)
    }
    #[inline]
    pub unsafe fn drawOval(&mut self, oval: *const SkRect, paint: *const SkPaint) {
        SkCanvas_drawOval(self, oval, paint)
    }
    #[inline]
    pub unsafe fn drawRRect(&mut self, rrect: *const SkRRect, paint: *const SkPaint) {
        SkCanvas_drawRRect(self, rrect, paint)
    }
    #[inline]
    pub unsafe fn drawDRRect(
        &mut self,
        outer: *const SkRRect,
        inner: *const SkRRect,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawDRRect(self, outer, inner, paint)
    }
    #[inline]
    pub unsafe fn drawCircle(
        &mut self,
        cx: SkScalar,
        cy: SkScalar,
        radius: SkScalar,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawCircle(self, cx, cy, radius, paint)
    }
    #[inline]
    pub unsafe fn drawArc(
        &mut self,
        oval: *const SkRect,
        startAngle: SkScalar,
        sweepAngle: SkScalar,
        useCenter: bool,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawArc(self, oval, startAngle, sweepAngle, useCenter, paint)
    }
    #[inline]
    pub unsafe fn drawRoundRect(
        &mut self,
        rect: *const SkRect,
        rx: SkScalar,
        ry: SkScalar,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawRoundRect(self, rect, rx, ry, paint)
    }
    #[inline]
    pub unsafe fn drawPath(&mut self, path: *const SkPath, paint: *const SkPaint) {
        SkCanvas_drawPath(self, path, paint)
    }
    #[inline]
    pub unsafe fn drawImage(
        &mut self,
        image: *const SkImage,
        left: SkScalar,
        top: SkScalar,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawImage(self, image, left, top, paint)
    }
    #[inline]
    pub unsafe fn drawImageRect(
        &mut self,
        image: *const SkImage,
        src: *const SkRect,
        dst: *const SkRect,
        paint: *const SkPaint,
        constraint: SkCanvas_SrcRectConstraint,
    ) {
        SkCanvas_drawImageRect(self, image, src, dst, paint, constraint)
    }
    #[inline]
    pub unsafe fn drawImageRect1(
        &mut self,
        image: *const SkImage,
        isrc: *const SkIRect,
        dst: *const SkRect,
        paint: *const SkPaint,
        constraint: SkCanvas_SrcRectConstraint,
    ) {
        SkCanvas_drawImageRect1(self, image, isrc, dst, paint, constraint)
    }
    #[inline]
    pub unsafe fn drawImageRect2(
        &mut self,
        image: *const SkImage,
        dst: *const SkRect,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawImageRect2(self, image, dst, paint)
    }
    #[inline]
    pub unsafe fn drawImageNine(
        &mut self,
        image: *const SkImage,
        center: *const SkIRect,
        dst: *const SkRect,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawImageNine(self, image, center, dst, paint)
    }
    #[inline]
    pub unsafe fn drawBitmap(
        &mut self,
        bitmap: *const SkBitmap,
        left: SkScalar,
        top: SkScalar,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawBitmap(self, bitmap, left, top, paint)
    }
    #[inline]
    pub unsafe fn drawBitmapRect(
        &mut self,
        bitmap: *const SkBitmap,
        src: *const SkRect,
        dst: *const SkRect,
        paint: *const SkPaint,
        constraint: SkCanvas_SrcRectConstraint,
    ) {
        SkCanvas_drawBitmapRect(self, bitmap, src, dst, paint, constraint)
    }
    #[inline]
    pub unsafe fn drawBitmapRect1(
        &mut self,
        bitmap: *const SkBitmap,
        isrc: *const SkIRect,
        dst: *const SkRect,
        paint: *const SkPaint,
        constraint: SkCanvas_SrcRectConstraint,
    ) {
        SkCanvas_drawBitmapRect1(self, bitmap, isrc, dst, paint, constraint)
    }
    #[inline]
    pub unsafe fn drawBitmapRect2(
        &mut self,
        bitmap: *const SkBitmap,
        dst: *const SkRect,
        paint: *const SkPaint,
        constraint: SkCanvas_SrcRectConstraint,
    ) {
        SkCanvas_drawBitmapRect2(self, bitmap, dst, paint, constraint)
    }
    #[inline]
    pub unsafe fn drawBitmapNine(
        &mut self,
        bitmap: *const SkBitmap,
        center: *const SkIRect,
        dst: *const SkRect,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawBitmapNine(self, bitmap, center, dst, paint)
    }
    #[inline]
    pub unsafe fn drawBitmapLattice(
        &mut self,
        bitmap: *const SkBitmap,
        lattice: *const SkCanvas_Lattice,
        dst: *const SkRect,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawBitmapLattice(self, bitmap, lattice, dst, paint)
    }
    #[inline]
    pub unsafe fn drawImageLattice(
        &mut self,
        image: *const SkImage,
        lattice: *const SkCanvas_Lattice,
        dst: *const SkRect,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawImageLattice(self, image, lattice, dst, paint)
    }
    #[inline]
    pub unsafe fn experimental_DrawEdgeAAQuad(
        &mut self,
        rect: *const SkRect,
        clip: *const SkPoint,
        aaFlags: SkCanvas_QuadAAFlags,
        color: SkColor,
        mode: SkBlendMode,
    ) {
        SkCanvas_experimental_DrawEdgeAAQuad(self, rect, clip, aaFlags, color, mode)
    }
    #[inline]
    pub unsafe fn experimental_DrawEdgeAAImageSet(
        &mut self,
        imageSet: *const SkCanvas_ImageSetEntry,
        cnt: ::std::os::raw::c_int,
        dstClips: *const SkPoint,
        preViewMatrices: *const SkMatrix,
        paint: *const SkPaint,
        constraint: SkCanvas_SrcRectConstraint,
    ) {
        SkCanvas_experimental_DrawEdgeAAImageSet(
            self,
            imageSet,
            cnt,
            dstClips,
            preViewMatrices,
            paint,
            constraint,
        )
    }
    #[inline]
    pub unsafe fn drawSimpleText(
        &mut self,
        text: *const ::std::os::raw::c_void,
        byteLength: usize,
        encoding: SkTextEncoding,
        x: SkScalar,
        y: SkScalar,
        font: *const SkFont,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawSimpleText(self, text, byteLength, encoding, x, y, font, paint)
    }
    #[inline]
    pub unsafe fn drawTextBlob(
        &mut self,
        blob: *const SkTextBlob,
        x: SkScalar,
        y: SkScalar,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawTextBlob(self, blob, x, y, paint)
    }
    #[inline]
    pub unsafe fn drawPicture(
        &mut self,
        picture: *const SkPicture,
        matrix: *const SkMatrix,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawPicture(self, picture, matrix, paint)
    }
    #[inline]
    pub unsafe fn drawVertices(
        &mut self,
        vertices: *const SkVertices,
        mode: SkBlendMode,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawVertices(self, vertices, mode, paint)
    }
    #[inline]
    pub unsafe fn drawVertices1(
        &mut self,
        vertices: *const sk_sp<SkVertices>,
        mode: SkBlendMode,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawVertices1(self, vertices, mode, paint)
    }
    #[inline]
    pub unsafe fn drawVertices2(
        &mut self,
        vertices: *const SkVertices,
        bones: *const SkVertices_Bone,
        boneCount: ::std::os::raw::c_int,
        mode: SkBlendMode,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawVertices2(self, vertices, bones, boneCount, mode, paint)
    }
    #[inline]
    pub unsafe fn drawVertices3(
        &mut self,
        vertices: *const sk_sp<SkVertices>,
        bones: *const SkVertices_Bone,
        boneCount: ::std::os::raw::c_int,
        mode: SkBlendMode,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawVertices3(self, vertices, bones, boneCount, mode, paint)
    }
    #[inline]
    pub unsafe fn drawPatch(
        &mut self,
        cubics: *const SkPoint,
        colors: *const SkColor,
        texCoords: *const SkPoint,
        mode: SkBlendMode,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawPatch(self, cubics, colors, texCoords, mode, paint)
    }
    #[inline]
    pub unsafe fn drawAtlas(
        &mut self,
        atlas: *const SkImage,
        xform: *const SkRSXform,
        tex: *const SkRect,
        colors: *const SkColor,
        count: ::std::os::raw::c_int,
        mode: SkBlendMode,
        cullRect: *const SkRect,
        paint: *const SkPaint,
    ) {
        SkCanvas_drawAtlas(
            self, atlas, xform, tex, colors, count, mode, cullRect, paint,
        )
    }
    #[inline]
    pub unsafe fn drawDrawable(&mut self, drawable: *mut SkDrawable, matrix: *const SkMatrix) {
        SkCanvas_drawDrawable(self, drawable, matrix)
    }
    #[inline]
    pub unsafe fn drawDrawable1(&mut self, drawable: *mut SkDrawable, x: SkScalar, y: SkScalar) {
        SkCanvas_drawDrawable1(self, drawable, x, y)
    }
    #[inline]
    pub unsafe fn drawAnnotation(
        &mut self,
        rect: *const SkRect,
        key: *const ::std::os::raw::c_char,
        value: *mut SkData,
    ) {
        SkCanvas_drawAnnotation(self, rect, key, value)
    }
    #[inline]
    pub unsafe fn getTotalMatrix(&self) -> *const SkMatrix {
        SkCanvas_getTotalMatrix(self)
    }
    #[inline]
    pub unsafe fn legacy_drawImageRect(
        &mut self,
        image: *const SkImage,
        src: *const SkRect,
        dst: *const SkRect,
        paint: *const SkPaint,
        constraint: SkCanvas_SrcRectConstraint,
    ) {
        SkCanvas_legacy_drawImageRect(self, image, src, dst, paint, constraint)
    }
    #[inline]
    pub unsafe fn legacy_drawBitmapRect(
        &mut self,
        bitmap: *const SkBitmap,
        src: *const SkRect,
        dst: *const SkRect,
        paint: *const SkPaint,
        constraint: SkCanvas_SrcRectConstraint,
    ) {
        SkCanvas_legacy_drawBitmapRect(self, bitmap, src, dst, paint, constraint)
    }
    #[inline]
    pub unsafe fn temporary_internal_getRgnClip(&mut self, region: *mut SkRegion) {
        SkCanvas_temporary_internal_getRgnClip(self, region)
    }
    #[inline]
    pub unsafe fn private_draw_shadow_rec(
        &mut self,
        arg1: *const SkPath,
        arg2: *const SkDrawShadowRec,
    ) {
        SkCanvas_private_draw_shadow_rec(self, arg1, arg2)
    }
    #[inline]
    pub unsafe fn clipRectBounds(
        &mut self,
        bounds: *const SkRect,
        flags: SkCanvas_SaveLayerFlags,
        intersection: *mut SkIRect,
        imageFilter: *const SkImageFilter,
    ) -> bool {
        SkCanvas_clipRectBounds(self, bounds, flags, intersection, imageFilter)
    }
    #[inline]
    pub unsafe fn getTopDevice(&self) -> *mut SkBaseDevice {
        SkCanvas_getTopDevice(self)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkCanvas_SkCanvas(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        props: *const SkSurfaceProps,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkCanvas_SkCanvas1(&mut __bindgen_tmp, width, height, props);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new2(device: sk_sp<SkBaseDevice>) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkCanvas_SkCanvas2(&mut __bindgen_tmp, device);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new3(bitmap: *const SkBitmap) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkCanvas_SkCanvas3(&mut __bindgen_tmp, bitmap);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new4(bitmap: *const SkBitmap, props: *const SkSurfaceProps) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkCanvas_SkCanvas4(&mut __bindgen_tmp, bitmap, props);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new5(bounds: *const SkIRect) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkCanvas_SkCanvas5(&mut __bindgen_tmp, bounds);
        __bindgen_tmp
    }
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvasD1Ev"]
    pub fn SkCanvas_SkCanvas_destructor(this: *mut SkCanvas);
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas16getBaseLayerSizeEv"]
    pub fn SkCanvas_getBaseLayerSize(this: *mut ::std::os::raw::c_void) -> SkISize;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas12getGrContextEv"]
    pub fn SkCanvas_getGrContext(this: *mut ::std::os::raw::c_void) -> *mut GrContext;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas11isClipEmptyEv"]
    pub fn SkCanvas_isClipEmpty(this: *mut ::std::os::raw::c_void) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas10isClipRectEv"]
    pub fn SkCanvas_isClipRect(this: *mut ::std::os::raw::c_void) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas50internal_private_accessTopLayerRenderTargetContextEv"]
    pub fn SkCanvas_internal_private_accessTopLayerRenderTargetContext(
        this: *mut ::std::os::raw::c_void,
    ) -> *mut GrRenderTargetContext;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas12onNewSurfaceERK11SkImageInfoRK14SkSurfaceProps"]
    pub fn SkCanvas_onNewSurface(
        this: *mut ::std::os::raw::c_void,
        info: *const SkImageInfo,
        props: *const SkSurfaceProps,
    ) -> sk_sp<SkSurface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas12onPeekPixelsEP8SkPixmap"]
    pub fn SkCanvas_onPeekPixels(this: *mut ::std::os::raw::c_void, pixmap: *mut SkPixmap) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas22onAccessTopLayerPixelsEP8SkPixmap"]
    pub fn SkCanvas_onAccessTopLayerPixels(
        this: *mut ::std::os::raw::c_void,
        pixmap: *mut SkPixmap,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas11onImageInfoEv"]
    pub fn SkCanvas_onImageInfo(this: *mut ::std::os::raw::c_void) -> SkImageInfo;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkCanvas10onGetPropsEP14SkSurfaceProps"]
    pub fn SkCanvas_onGetProps(
        this: *mut ::std::os::raw::c_void,
        props: *mut SkSurfaceProps,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas7onFlushEv"]
    pub fn SkCanvas_onFlush(this: *mut ::std::os::raw::c_void);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas11onDrawPaintERK7SkPaint"]
    pub fn SkCanvas_onDrawPaint(this: *mut ::std::os::raw::c_void, paint: *const SkPaint);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas12onDrawBehindERK7SkPaint"]
    pub fn SkCanvas_onDrawBehind(this: *mut ::std::os::raw::c_void, paint: *const SkPaint);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas10onDrawRectERK6SkRectRK7SkPaint"]
    pub fn SkCanvas_onDrawRect(
        this: *mut ::std::os::raw::c_void,
        rect: *const SkRect,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas11onDrawRRectERK7SkRRectRK7SkPaint"]
    pub fn SkCanvas_onDrawRRect(
        this: *mut ::std::os::raw::c_void,
        rrect: *const SkRRect,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas12onDrawDRRectERK7SkRRectS2_RK7SkPaint"]
    pub fn SkCanvas_onDrawDRRect(
        this: *mut ::std::os::raw::c_void,
        outer: *const SkRRect,
        inner: *const SkRRect,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas10onDrawOvalERK6SkRectRK7SkPaint"]
    pub fn SkCanvas_onDrawOval(
        this: *mut ::std::os::raw::c_void,
        rect: *const SkRect,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas9onDrawArcERK6SkRectffbRK7SkPaint"]
    pub fn SkCanvas_onDrawArc(
        this: *mut ::std::os::raw::c_void,
        rect: *const SkRect,
        startAngle: SkScalar,
        sweepAngle: SkScalar,
        useCenter: bool,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas10onDrawPathERK6SkPathRK7SkPaint"]
    pub fn SkCanvas_onDrawPath(
        this: *mut ::std::os::raw::c_void,
        path: *const SkPath,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas12onDrawRegionERK8SkRegionRK7SkPaint"]
    pub fn SkCanvas_onDrawRegion(
        this: *mut ::std::os::raw::c_void,
        region: *const SkRegion,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas14onDrawTextBlobEPK10SkTextBlobffRK7SkPaint"]
    pub fn SkCanvas_onDrawTextBlob(
        this: *mut ::std::os::raw::c_void,
        blob: *const SkTextBlob,
        x: SkScalar,
        y: SkScalar,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas11onDrawPatchEPK7SkPointPKjS2_11SkBlendModeRK7SkPaint"]
    pub fn SkCanvas_onDrawPatch(
        this: *mut ::std::os::raw::c_void,
        cubics: *const SkPoint,
        colors: *const SkColor,
        texCoords: *const SkPoint,
        mode: SkBlendMode,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas12onDrawPointsENS_9PointModeEmPK7SkPointRK7SkPaint"]
    pub fn SkCanvas_onDrawPoints(
        this: *mut ::std::os::raw::c_void,
        mode: SkCanvas_PointMode,
        count: usize,
        pts: *const SkPoint,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas20onDrawVerticesObjectEPK10SkVerticesPKNS0_4BoneEi11SkBlendModeRK7SkPaint"]
    pub fn SkCanvas_onDrawVerticesObject(
        this: *mut ::std::os::raw::c_void,
        vertices: *const SkVertices,
        bones: *const SkVertices_Bone,
        boneCount: ::std::os::raw::c_int,
        mode: SkBlendMode,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas11onDrawImageEPK7SkImageffPK7SkPaint"]
    pub fn SkCanvas_onDrawImage(
        this: *mut ::std::os::raw::c_void,
        image: *const SkImage,
        dx: SkScalar,
        dy: SkScalar,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas15onDrawImageRectEPK7SkImagePK6SkRectRS4_PK7SkPaintNS_17SrcRectConstraintE"]
    pub fn SkCanvas_onDrawImageRect(
        this: *mut ::std::os::raw::c_void,
        image: *const SkImage,
        src: *const SkRect,
        dst: *const SkRect,
        paint: *const SkPaint,
        constraint: SkCanvas_SrcRectConstraint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas15onDrawImageNineEPK7SkImageRK7SkIRectRK6SkRectPK7SkPaint"]
    pub fn SkCanvas_onDrawImageNine(
        this: *mut ::std::os::raw::c_void,
        image: *const SkImage,
        center: *const SkIRect,
        dst: *const SkRect,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas18onDrawImageLatticeEPK7SkImageRKNS_7LatticeERK6SkRectPK7SkPaint"]
    pub fn SkCanvas_onDrawImageLattice(
        this: *mut ::std::os::raw::c_void,
        image: *const SkImage,
        lattice: *const SkCanvas_Lattice,
        dst: *const SkRect,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas12onDrawBitmapERK8SkBitmapffPK7SkPaint"]
    pub fn SkCanvas_onDrawBitmap(
        this: *mut ::std::os::raw::c_void,
        bitmap: *const SkBitmap,
        dx: SkScalar,
        dy: SkScalar,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas16onDrawBitmapRectERK8SkBitmapPK6SkRectRS4_PK7SkPaintNS_17SrcRectConstraintE"]
    pub fn SkCanvas_onDrawBitmapRect(
        this: *mut ::std::os::raw::c_void,
        bitmap: *const SkBitmap,
        src: *const SkRect,
        dst: *const SkRect,
        paint: *const SkPaint,
        constraint: SkCanvas_SrcRectConstraint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas16onDrawBitmapNineERK8SkBitmapRK7SkIRectRK6SkRectPK7SkPaint"]
    pub fn SkCanvas_onDrawBitmapNine(
        this: *mut ::std::os::raw::c_void,
        bitmap: *const SkBitmap,
        center: *const SkIRect,
        dst: *const SkRect,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas19onDrawBitmapLatticeERK8SkBitmapRKNS_7LatticeERK6SkRectPK7SkPaint"]
    pub fn SkCanvas_onDrawBitmapLattice(
        this: *mut ::std::os::raw::c_void,
        bitmap: *const SkBitmap,
        lattice: *const SkCanvas_Lattice,
        dst: *const SkRect,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas11onDrawAtlasEPK7SkImagePK9SkRSXformPK6SkRectPKji11SkBlendModeS8_PK7SkPaint"]
    pub fn SkCanvas_onDrawAtlas(
        this: *mut ::std::os::raw::c_void,
        atlas: *const SkImage,
        xform: *const SkRSXform,
        rect: *const SkRect,
        colors: *const SkColor,
        count: ::std::os::raw::c_int,
        mode: SkBlendMode,
        cull: *const SkRect,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas16onDrawAnnotationERK6SkRectPKcP6SkData"]
    pub fn SkCanvas_onDrawAnnotation(
        this: *mut ::std::os::raw::c_void,
        rect: *const SkRect,
        key: *const ::std::os::raw::c_char,
        value: *mut SkData,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas15onDrawShadowRecERK6SkPathRK15SkDrawShadowRec"]
    pub fn SkCanvas_onDrawShadowRec(
        this: *mut ::std::os::raw::c_void,
        arg1: *const SkPath,
        arg2: *const SkDrawShadowRec,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas14onDrawDrawableEP10SkDrawablePK8SkMatrix"]
    pub fn SkCanvas_onDrawDrawable(
        this: *mut ::std::os::raw::c_void,
        drawable: *mut SkDrawable,
        matrix: *const SkMatrix,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas13onDrawPictureEPK9SkPicturePK8SkMatrixPK7SkPaint"]
    pub fn SkCanvas_onDrawPicture(
        this: *mut ::std::os::raw::c_void,
        picture: *const SkPicture,
        matrix: *const SkMatrix,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas16onDrawEdgeAAQuadERK6SkRectPK7SkPointNS_11QuadAAFlagsEj11SkBlendMode"]
    pub fn SkCanvas_onDrawEdgeAAQuad(
        this: *mut ::std::os::raw::c_void,
        rect: *const SkRect,
        clip: *const SkPoint,
        aaFlags: SkCanvas_QuadAAFlags,
        color: SkColor,
        mode: SkBlendMode,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas20onDrawEdgeAAImageSetEPKNS_13ImageSetEntryEiPK7SkPointPK8SkMatrixPK7SkPaintNS_17SrcRectConstraintE"]
    pub fn SkCanvas_onDrawEdgeAAImageSet(
        this: *mut ::std::os::raw::c_void,
        imageSet: *const SkCanvas_ImageSetEntry,
        count: ::std::os::raw::c_int,
        dstClips: *const SkPoint,
        preViewMatrices: *const SkMatrix,
        paint: *const SkPaint,
        constraint: SkCanvas_SrcRectConstraint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas10onClipRectERK6SkRect8SkClipOpNS_13ClipEdgeStyleE"]
    pub fn SkCanvas_onClipRect(
        this: *mut ::std::os::raw::c_void,
        rect: *const SkRect,
        op: SkClipOp,
        edgeStyle: SkCanvas_ClipEdgeStyle,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas11onClipRRectERK7SkRRect8SkClipOpNS_13ClipEdgeStyleE"]
    pub fn SkCanvas_onClipRRect(
        this: *mut ::std::os::raw::c_void,
        rrect: *const SkRRect,
        op: SkClipOp,
        edgeStyle: SkCanvas_ClipEdgeStyle,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas10onClipPathERK6SkPath8SkClipOpNS_13ClipEdgeStyleE"]
    pub fn SkCanvas_onClipPath(
        this: *mut ::std::os::raw::c_void,
        path: *const SkPath,
        op: SkClipOp,
        edgeStyle: SkCanvas_ClipEdgeStyle,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas12onClipRegionERK8SkRegion8SkClipOp"]
    pub fn SkCanvas_onClipRegion(
        this: *mut ::std::os::raw::c_void,
        deviceRgn: *const SkRegion,
        op: SkClipOp,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkCanvas9onDiscardEv"]
    pub fn SkCanvas_onDiscard(this: *mut ::std::os::raw::c_void);
}
#[repr(C)]
pub struct SkAutoCanvasRestore {
    pub fCanvas: *mut SkCanvas,
    pub fSaveCount: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_SkAutoCanvasRestore() {
    assert_eq!(
        ::core::mem::size_of::<SkAutoCanvasRestore>(),
        16usize,
        concat!("Size of: ", stringify!(SkAutoCanvasRestore))
    );
    assert_eq!(
        ::core::mem::align_of::<SkAutoCanvasRestore>(),
        8usize,
        concat!("Alignment of ", stringify!(SkAutoCanvasRestore))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkAutoCanvasRestore>())).fCanvas as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkAutoCanvasRestore),
            "::",
            stringify!(fCanvas)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkAutoCanvasRestore>())).fSaveCount as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkAutoCanvasRestore),
            "::",
            stringify!(fSaveCount)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkSerialProcs {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkDeserialProcs {
    _unused: [u8; 0],
}
#[repr(C)]
pub struct SkFlattenable {
    pub _base: SkRefCnt,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkFlattenable_Type {
    kSkColorFilter_Type = 0,
    kSkDrawable_Type = 1,
    kSkDrawLooper_Type = 2,
    kSkImageFilter_Type = 3,
    kSkMaskFilter_Type = 4,
    kSkPathEffect_Type = 5,
    kSkPixelRef_Type = 6,
    kSkUnused_Type4 = 7,
    kSkShaderBase_Type = 8,
    kSkUnused_Type = 9,
    kSkUnused_Type2 = 10,
    kSkNormalSource_Type = 11,
}
pub type SkFlattenable_Factory =
    ::core::option::Option<unsafe extern "C" fn(arg1: *mut SkReadBuffer) -> sk_sp<SkFlattenable>>;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkFlattenable_PrivateInitializer {
    pub _address: u8,
}
#[test]
fn bindgen_test_layout_SkFlattenable_PrivateInitializer() {
    assert_eq!(
        ::core::mem::size_of::<SkFlattenable_PrivateInitializer>(),
        1usize,
        concat!("Size of: ", stringify!(SkFlattenable_PrivateInitializer))
    );
    assert_eq!(
        ::core::mem::align_of::<SkFlattenable_PrivateInitializer>(),
        1usize,
        concat!(
            "Alignment of ",
            stringify!(SkFlattenable_PrivateInitializer)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkFlattenable18PrivateInitializer11InitEffectsEv"]
    pub fn SkFlattenable_PrivateInitializer_InitEffects();
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkFlattenable18PrivateInitializer16InitImageFiltersEv"]
    pub fn SkFlattenable_PrivateInitializer_InitImageFilters();
}
impl SkFlattenable_PrivateInitializer {
    #[inline]
    pub unsafe fn InitEffects() {
        SkFlattenable_PrivateInitializer_InitEffects()
    }
    #[inline]
    pub unsafe fn InitImageFilters() {
        SkFlattenable_PrivateInitializer_InitImageFilters()
    }
}
pub type SkFlattenable_INHERITED = SkRefCnt;
#[test]
fn bindgen_test_layout_SkFlattenable() {
    assert_eq!(
        ::core::mem::size_of::<SkFlattenable>(),
        16usize,
        concat!("Size of: ", stringify!(SkFlattenable))
    );
    assert_eq!(
        ::core::mem::align_of::<SkFlattenable>(),
        8usize,
        concat!("Alignment of ", stringify!(SkFlattenable))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkFlattenable13NameToFactoryEPKc"]
    pub fn SkFlattenable_NameToFactory(
        name: *const ::std::os::raw::c_char,
    ) -> SkFlattenable_Factory;
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkFlattenable13FactoryToNameEPF5sk_spIS_ER12SkReadBufferE"]
    pub fn SkFlattenable_FactoryToName(
        arg1: SkFlattenable_Factory,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkFlattenable8RegisterEPKcPF5sk_spIS_ER12SkReadBufferE"]
    pub fn SkFlattenable_Register(name: *const ::std::os::raw::c_char, arg1: SkFlattenable_Factory);
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkFlattenable9serializeEPK13SkSerialProcs"]
    pub fn SkFlattenable_serialize(
        this: *const SkFlattenable,
        arg1: *const SkSerialProcs,
    ) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkFlattenable9serializeEPvmPK13SkSerialProcs"]
    pub fn SkFlattenable_serialize1(
        this: *const SkFlattenable,
        memory: *mut ::std::os::raw::c_void,
        memory_size: usize,
        arg1: *const SkSerialProcs,
    ) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkFlattenable11DeserializeENS_4TypeEPKvmPK15SkDeserialProcs"]
    pub fn SkFlattenable_Deserialize(
        arg1: SkFlattenable_Type,
        data: *const ::std::os::raw::c_void,
        length: usize,
        procs: *const SkDeserialProcs,
    ) -> sk_sp<SkFlattenable>;
}
impl SkFlattenable {
    #[inline]
    pub unsafe fn NameToFactory(name: *const ::std::os::raw::c_char) -> SkFlattenable_Factory {
        SkFlattenable_NameToFactory(name)
    }
    #[inline]
    pub unsafe fn FactoryToName(arg1: SkFlattenable_Factory) -> *const ::std::os::raw::c_char {
        SkFlattenable_FactoryToName(arg1)
    }
    #[inline]
    pub unsafe fn Register(name: *const ::std::os::raw::c_char, arg1: SkFlattenable_Factory) {
        SkFlattenable_Register(name, arg1)
    }
    #[inline]
    pub unsafe fn serialize(&self, arg1: *const SkSerialProcs) -> sk_sp<SkData> {
        SkFlattenable_serialize(self, arg1)
    }
    #[inline]
    pub unsafe fn serialize1(
        &self,
        memory: *mut ::std::os::raw::c_void,
        memory_size: usize,
        arg1: *const SkSerialProcs,
    ) -> usize {
        SkFlattenable_serialize1(self, memory, memory_size, arg1)
    }
    #[inline]
    pub unsafe fn Deserialize(
        arg1: SkFlattenable_Type,
        data: *const ::std::os::raw::c_void,
        length: usize,
        procs: *const SkDeserialProcs,
    ) -> sk_sp<SkFlattenable> {
        SkFlattenable_Deserialize(arg1, data, length, procs)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrColorSpaceInfo {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrFragmentProcessor {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkStageRec {
    _unused: [u8; 0],
}
#[repr(C)]
pub struct SkColorFilter {
    pub _base: SkFlattenable,
}
pub const SkColorFilter_Flags_kAlphaUnchanged_Flag: SkColorFilter_Flags = 1;
pub type SkColorFilter_Flags = u32;
pub type SkColorFilter_INHERITED = SkFlattenable;
#[test]
fn bindgen_test_layout_SkColorFilter() {
    assert_eq!(
        ::core::mem::size_of::<SkColorFilter>(),
        16usize,
        concat!("Size of: ", stringify!(SkColorFilter))
    );
    assert_eq!(
        ::core::mem::align_of::<SkColorFilter>(),
        8usize,
        concat!("Alignment of ", stringify!(SkColorFilter))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkColorFilter12appendStagesERK10SkStageRecb"]
    pub fn SkColorFilter_appendStages(
        this: *const SkColorFilter,
        rec: *const SkStageRec,
        shaderIsOpaque: bool,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkColorFilter11filterColorEj"]
    pub fn SkColorFilter_filterColor(this: *const SkColorFilter, arg1: SkColor) -> SkColor;
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkColorFilter13filterColor4fERK8SkRGBA4fIL11SkAlphaType3EEP12SkColorSpace"]
    pub fn SkColorFilter_filterColor4f(
        this: *const SkColorFilter,
        arg1: *const SkColor4f,
        arg2: *mut SkColorSpace,
    ) -> SkColor4f;
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkColorFilter12makeComposedE5sk_spIS_E"]
    pub fn SkColorFilter_makeComposed(
        this: *const SkColorFilter,
        inner: sk_sp<SkColorFilter>,
    ) -> sk_sp<SkColorFilter>;
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkColorFilter20RegisterFlattenablesEv"]
    pub fn SkColorFilter_RegisterFlattenables();
}
impl SkColorFilter {
    #[inline]
    pub unsafe fn appendStages(&self, rec: *const SkStageRec, shaderIsOpaque: bool) -> bool {
        SkColorFilter_appendStages(self, rec, shaderIsOpaque)
    }
    #[inline]
    pub unsafe fn filterColor(&self, arg1: SkColor) -> SkColor {
        SkColorFilter_filterColor(self, arg1)
    }
    #[inline]
    pub unsafe fn filterColor4f(
        &self,
        arg1: *const SkColor4f,
        arg2: *mut SkColorSpace,
    ) -> SkColor4f {
        SkColorFilter_filterColor4f(self, arg1, arg2)
    }
    #[inline]
    pub unsafe fn makeComposed(&self, inner: sk_sp<SkColorFilter>) -> sk_sp<SkColorFilter> {
        SkColorFilter_makeComposed(self, inner)
    }
    #[inline]
    pub unsafe fn RegisterFlattenables() {
        SkColorFilter_RegisterFlattenables()
    }
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkColorFilter19asFragmentProcessorEP18GrRecordingContextRK16GrColorSpaceInfo"]
    pub fn SkColorFilter_asFragmentProcessor(
        this: *mut ::std::os::raw::c_void,
        arg1: *mut GrRecordingContext,
        dstColorSpaceInfo: *const GrColorSpaceInfo,
    ) -> u8;
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkColorFilter16onAsAColorMatrixEPf"]
    pub fn SkColorFilter_onAsAColorMatrix(
        this: *mut ::std::os::raw::c_void,
        arg1: *mut f32,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkColorFilter14onAsAColorModeEPjP11SkBlendMode"]
    pub fn SkColorFilter_onAsAColorMode(
        this: *mut ::std::os::raw::c_void,
        color: *mut SkColor,
        bmode: *mut SkBlendMode,
    ) -> bool;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkRRect {
    pub fRect: SkRect,
    pub fRadii: [SkVector; 4usize],
    pub fType: i32,
}
impl SkRRect_Type {
    pub const kLastType: SkRRect_Type = SkRRect_Type::kComplex_Type;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkRRect_Type {
    kEmpty_Type = 0,
    kRect_Type = 1,
    kOval_Type = 2,
    kSimple_Type = 3,
    kNinePatch_Type = 4,
    kComplex_Type = 5,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkRRect_Corner {
    kUpperLeft_Corner = 0,
    kUpperRight_Corner = 1,
    kLowerRight_Corner = 2,
    kLowerLeft_Corner = 3,
}
pub const SkRRect_kSizeInMemory: usize = 48;
#[test]
fn bindgen_test_layout_SkRRect() {
    assert_eq!(
        ::core::mem::size_of::<SkRRect>(),
        52usize,
        concat!("Size of: ", stringify!(SkRRect))
    );
    assert_eq!(
        ::core::mem::align_of::<SkRRect>(),
        4usize,
        concat!("Alignment of ", stringify!(SkRRect))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRRect>())).fRect as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRRect),
            "::",
            stringify!(fRect)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRRect>())).fRadii as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRRect),
            "::",
            stringify!(fRadii)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRRect>())).fType as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRRect),
            "::",
            stringify!(fType)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkRRect9setRectXYERK6SkRectff"]
    pub fn SkRRect_setRectXY(
        this: *mut SkRRect,
        rect: *const SkRect,
        xRad: SkScalar,
        yRad: SkScalar,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkRRect12setNinePatchERK6SkRectffff"]
    pub fn SkRRect_setNinePatch(
        this: *mut SkRRect,
        rect: *const SkRect,
        leftRad: SkScalar,
        topRad: SkScalar,
        rightRad: SkScalar,
        bottomRad: SkScalar,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkRRect12setRectRadiiERK6SkRectPK7SkPoint"]
    pub fn SkRRect_setRectRadii(this: *mut SkRRect, rect: *const SkRect, radii: *const SkVector);
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkRRect5insetEffPS_"]
    pub fn SkRRect_inset(this: *const SkRRect, dx: SkScalar, dy: SkScalar, dst: *mut SkRRect);
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkRRect8containsERK6SkRect"]
    pub fn SkRRect_contains(this: *const SkRRect, rect: *const SkRect) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkRRect7isValidEv"]
    pub fn SkRRect_isValid(this: *const SkRRect) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkRRect13writeToMemoryEPv"]
    pub fn SkRRect_writeToMemory(
        this: *const SkRRect,
        buffer: *mut ::std::os::raw::c_void,
    ) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkRRect14readFromMemoryEPKvm"]
    pub fn SkRRect_readFromMemory(
        this: *mut SkRRect,
        buffer: *const ::std::os::raw::c_void,
        length: usize,
    ) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkRRect9transformERK8SkMatrixPS_"]
    pub fn SkRRect_transform(
        this: *const SkRRect,
        matrix: *const SkMatrix,
        dst: *mut SkRRect,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkRRect4dumpEb"]
    pub fn SkRRect_dump(this: *const SkRRect, asHex: bool);
}
impl SkRRect {
    #[inline]
    pub unsafe fn setRectXY(&mut self, rect: *const SkRect, xRad: SkScalar, yRad: SkScalar) {
        SkRRect_setRectXY(self, rect, xRad, yRad)
    }
    #[inline]
    pub unsafe fn setNinePatch(
        &mut self,
        rect: *const SkRect,
        leftRad: SkScalar,
        topRad: SkScalar,
        rightRad: SkScalar,
        bottomRad: SkScalar,
    ) {
        SkRRect_setNinePatch(self, rect, leftRad, topRad, rightRad, bottomRad)
    }
    #[inline]
    pub unsafe fn setRectRadii(&mut self, rect: *const SkRect, radii: *const SkVector) {
        SkRRect_setRectRadii(self, rect, radii)
    }
    #[inline]
    pub unsafe fn inset(&self, dx: SkScalar, dy: SkScalar, dst: *mut SkRRect) {
        SkRRect_inset(self, dx, dy, dst)
    }
    #[inline]
    pub unsafe fn contains(&self, rect: *const SkRect) -> bool {
        SkRRect_contains(self, rect)
    }
    #[inline]
    pub unsafe fn isValid(&self) -> bool {
        SkRRect_isValid(self)
    }
    #[inline]
    pub unsafe fn writeToMemory(&self, buffer: *mut ::std::os::raw::c_void) -> usize {
        SkRRect_writeToMemory(self, buffer)
    }
    #[inline]
    pub unsafe fn readFromMemory(
        &mut self,
        buffer: *const ::std::os::raw::c_void,
        length: usize,
    ) -> usize {
        SkRRect_readFromMemory(self, buffer, length)
    }
    #[inline]
    pub unsafe fn transform(&self, matrix: *const SkMatrix, dst: *mut SkRRect) -> bool {
        SkRRect_transform(self, matrix, dst)
    }
    #[inline]
    pub unsafe fn dump(&self, asHex: bool) {
        SkRRect_dump(self, asHex)
    }
}
#[repr(C)]
pub struct SkSemaphore {
    pub fCount: u32,
    pub fOSSemaphoreOnce: SkOnce,
    pub fOSSemaphore: *mut SkSemaphore_OSSemaphore,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkSemaphore_OSSemaphore {
    _unused: [u8; 0],
}
#[test]
fn bindgen_test_layout_SkSemaphore() {
    assert_eq!(
        ::core::mem::size_of::<SkSemaphore>(),
        16usize,
        concat!("Size of: ", stringify!(SkSemaphore))
    );
    assert_eq!(
        ::core::mem::align_of::<SkSemaphore>(),
        8usize,
        concat!("Alignment of ", stringify!(SkSemaphore))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkSemaphore>())).fCount as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkSemaphore),
            "::",
            stringify!(fCount)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkSemaphore>())).fOSSemaphoreOnce as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkSemaphore),
            "::",
            stringify!(fOSSemaphoreOnce)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkSemaphore>())).fOSSemaphore as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkSemaphore),
            "::",
            stringify!(fOSSemaphore)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkSemaphore6signalEi"]
    pub fn SkSemaphore_signal(this: *mut SkSemaphore, n: ::std::os::raw::c_int);
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkSemaphore4waitEv"]
    pub fn SkSemaphore_wait(this: *mut SkSemaphore);
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkSemaphore8try_waitEv"]
    pub fn SkSemaphore_try_wait(this: *mut SkSemaphore) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkSemaphoreD1Ev"]
    pub fn SkSemaphore_SkSemaphore_destructor(this: *mut SkSemaphore);
}
impl SkSemaphore {
    #[inline]
    pub unsafe fn signal(&mut self, n: ::std::os::raw::c_int) {
        SkSemaphore_signal(self, n)
    }
    #[inline]
    pub unsafe fn wait(&mut self) {
        SkSemaphore_wait(self)
    }
    #[inline]
    pub unsafe fn try_wait(&mut self) -> bool {
        SkSemaphore_try_wait(self)
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        SkSemaphore_SkSemaphore_destructor(self)
    }
}
#[repr(C)]
pub struct SkMutex {
    pub fSemaphore: SkSemaphore,
}
#[test]
fn bindgen_test_layout_SkMutex() {
    assert_eq!(
        ::core::mem::size_of::<SkMutex>(),
        16usize,
        concat!("Size of: ", stringify!(SkMutex))
    );
    assert_eq!(
        ::core::mem::align_of::<SkMutex>(),
        8usize,
        concat!("Alignment of ", stringify!(SkMutex))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkMutex>())).fSemaphore as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkMutex),
            "::",
            stringify!(fSemaphore)
        )
    );
}
#[repr(C)]
pub struct SkTDArray<T> {
    pub fArray: *mut T,
    pub fReserve: ::std::os::raw::c_int,
    pub fCount: ::std::os::raw::c_int,
    pub _phantom_0: ::core::marker::PhantomData<::core::cell::UnsafeCell<T>>,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkRBuffer {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkWBuffer {
    _unused: [u8; 0],
}
#[repr(C)]
pub struct SkPathRef {
    pub _base: SkNVRefCnt,
    pub fBounds: SkRect,
    pub fPoints: *mut SkPoint,
    pub fVerbs: *mut u8,
    pub fVerbCnt: ::std::os::raw::c_int,
    pub fPointCnt: ::std::os::raw::c_int,
    pub fFreeSpace: usize,
    pub fConicWeights: SkTDArray<SkScalar>,
    pub fGenerationID: u32,
    pub fGenIDChangeListenersMutex: SkMutex,
    pub fGenIDChangeListeners: SkTDArray<*mut SkPathRef_GenIDChangeListener>,
    pub fBoundsIsDirty: u8,
    pub fIsFinite: bool,
    pub fIsOval: bool,
    pub fIsRRect: bool,
    pub fRRectOrOvalIsCCW: bool,
    pub fRRectOrOvalStartIdx: u8,
    pub fSegmentMask: u8,
}
#[repr(C)]
pub struct SkPathRef_Editor {
    pub fPathRef: *mut SkPathRef,
}
#[test]
fn bindgen_test_layout_SkPathRef_Editor() {
    assert_eq!(
        ::core::mem::size_of::<SkPathRef_Editor>(),
        8usize,
        concat!("Size of: ", stringify!(SkPathRef_Editor))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPathRef_Editor>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPathRef_Editor))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathRef_Editor>())).fPathRef as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef_Editor),
            "::",
            stringify!(fPathRef)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkPathRef6EditorC1EP5sk_spIS_Eii"]
    pub fn SkPathRef_Editor_Editor(
        this: *mut SkPathRef_Editor,
        pathRef: *mut sk_sp<SkPathRef>,
        incReserveVerbs: ::std::os::raw::c_int,
        incReservePoints: ::std::os::raw::c_int,
    );
}
impl SkPathRef_Editor {
    #[inline]
    pub unsafe fn new(
        pathRef: *mut sk_sp<SkPathRef>,
        incReserveVerbs: ::std::os::raw::c_int,
        incReservePoints: ::std::os::raw::c_int,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkPathRef_Editor_Editor(
            &mut __bindgen_tmp,
            pathRef,
            incReserveVerbs,
            incReservePoints,
        );
        __bindgen_tmp
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkPathRef_Iter {
    pub fPts: *const SkPoint,
    pub fVerbs: *const u8,
    pub fVerbStop: *const u8,
    pub fConicWeights: *const SkScalar,
}
#[test]
fn bindgen_test_layout_SkPathRef_Iter() {
    assert_eq!(
        ::core::mem::size_of::<SkPathRef_Iter>(),
        32usize,
        concat!("Size of: ", stringify!(SkPathRef_Iter))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPathRef_Iter>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPathRef_Iter))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathRef_Iter>())).fPts as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef_Iter),
            "::",
            stringify!(fPts)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathRef_Iter>())).fVerbs as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef_Iter),
            "::",
            stringify!(fVerbs)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathRef_Iter>())).fVerbStop as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef_Iter),
            "::",
            stringify!(fVerbStop)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathRef_Iter>())).fConicWeights as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef_Iter),
            "::",
            stringify!(fConicWeights)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkPathRef4Iter10setPathRefERKS_"]
    pub fn SkPathRef_Iter_setPathRef(this: *mut SkPathRef_Iter, arg1: *const SkPathRef);
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkPathRef4Iter4nextEP7SkPoint"]
    pub fn SkPathRef_Iter_next(this: *mut SkPathRef_Iter, pts: *mut SkPoint) -> u8;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkPathRef4Iter4peekEv"]
    pub fn SkPathRef_Iter_peek(this: *const SkPathRef_Iter) -> u8;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkPathRef4IterC1Ev"]
    pub fn SkPathRef_Iter_Iter(this: *mut SkPathRef_Iter);
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkPathRef4IterC1ERKS_"]
    pub fn SkPathRef_Iter_Iter1(this: *mut SkPathRef_Iter, arg1: *const SkPathRef);
}
impl SkPathRef_Iter {
    #[inline]
    pub unsafe fn setPathRef(&mut self, arg1: *const SkPathRef) {
        SkPathRef_Iter_setPathRef(self, arg1)
    }
    #[inline]
    pub unsafe fn next(&mut self, pts: *mut SkPoint) -> u8 {
        SkPathRef_Iter_next(self, pts)
    }
    #[inline]
    pub unsafe fn peek(&self) -> u8 {
        SkPathRef_Iter_peek(self)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkPathRef_Iter_Iter(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(arg1: *const SkPathRef) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkPathRef_Iter_Iter1(&mut __bindgen_tmp, arg1);
        __bindgen_tmp
    }
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub struct SkPathRef_GenIDChangeListener {
    pub _bindgen_opaque_blob: [u64; 2usize],
}
#[test]
fn bindgen_test_layout_SkPathRef_GenIDChangeListener() {
    assert_eq!(
        ::core::mem::size_of::<SkPathRef_GenIDChangeListener>(),
        16usize,
        concat!("Size of: ", stringify!(SkPathRef_GenIDChangeListener))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPathRef_GenIDChangeListener>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPathRef_GenIDChangeListener))
    );
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkPathRef_SerializationOffsets {
    kLegacyRRectOrOvalStartIdx_SerializationShift = 28,
    kLegacyRRectOrOvalIsCCW_SerializationShift = 27,
    kLegacyIsRRect_SerializationShift = 26,
    kIsFinite_SerializationShift = 25,
    kLegacyIsOval_SerializationShift = 24,
    kSegmentMask_SerializationShift = 0,
}
pub const SkPathRef_kMinSize: SkPathRef__bindgen_ty_1 = SkPathRef__bindgen_ty_1::kMinSize;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkPathRef__bindgen_ty_1 {
    kMinSize = 256,
}
pub const SkPathRef_kEmptyGenID: SkPathRef__bindgen_ty_2 = SkPathRef__bindgen_ty_2::kEmptyGenID;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkPathRef__bindgen_ty_2 {
    kEmptyGenID = 1,
}
#[test]
fn bindgen_test_layout_SkPathRef() {
    assert_eq!(
        ::core::mem::size_of::<SkPathRef>(),
        120usize,
        concat!("Size of: ", stringify!(SkPathRef))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPathRef>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPathRef))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathRef>())).fBounds as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef),
            "::",
            stringify!(fBounds)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathRef>())).fPoints as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef),
            "::",
            stringify!(fPoints)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathRef>())).fVerbs as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef),
            "::",
            stringify!(fVerbs)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathRef>())).fVerbCnt as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef),
            "::",
            stringify!(fVerbCnt)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathRef>())).fPointCnt as *const _ as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef),
            "::",
            stringify!(fPointCnt)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathRef>())).fFreeSpace as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef),
            "::",
            stringify!(fFreeSpace)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathRef>())).fConicWeights as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef),
            "::",
            stringify!(fConicWeights)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathRef>())).fGenerationID as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef),
            "::",
            stringify!(fGenerationID)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkPathRef>())).fGenIDChangeListenersMutex as *const _ as usize
        },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef),
            "::",
            stringify!(fGenIDChangeListenersMutex)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkPathRef>())).fGenIDChangeListeners as *const _ as usize
        },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef),
            "::",
            stringify!(fGenIDChangeListeners)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathRef>())).fBoundsIsDirty as *const _ as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef),
            "::",
            stringify!(fBoundsIsDirty)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathRef>())).fIsFinite as *const _ as usize },
        113usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef),
            "::",
            stringify!(fIsFinite)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathRef>())).fIsOval as *const _ as usize },
        114usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef),
            "::",
            stringify!(fIsOval)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathRef>())).fIsRRect as *const _ as usize },
        115usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef),
            "::",
            stringify!(fIsRRect)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathRef>())).fRRectOrOvalIsCCW as *const _ as usize },
        116usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef),
            "::",
            stringify!(fRRectOrOvalIsCCW)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathRef>())).fRRectOrOvalStartIdx as *const _ as usize },
        117usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef),
            "::",
            stringify!(fRRectOrOvalStartIdx)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathRef>())).fSegmentMask as *const _ as usize },
        118usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathRef),
            "::",
            stringify!(fSegmentMask)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkPathRef11CreateEmptyEv"]
    pub fn SkPathRef_CreateEmpty() -> *mut SkPathRef;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkPathRef8getRRectEv"]
    pub fn SkPathRef_getRRect(this: *const SkPathRef) -> SkRRect;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkPathRef21CreateTransformedCopyEP5sk_spIS_ERKS_RK8SkMatrix"]
    pub fn SkPathRef_CreateTransformedCopy(
        dst: *mut sk_sp<SkPathRef>,
        src: *const SkPathRef,
        matrix: *const SkMatrix,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkPathRef16CreateFromBufferEP9SkRBuffer"]
    pub fn SkPathRef_CreateFromBuffer(buffer: *mut SkRBuffer) -> *mut SkPathRef;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkPathRef6RewindEP5sk_spIS_E"]
    pub fn SkPathRef_Rewind(pathRef: *mut sk_sp<SkPathRef>);
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkPathRef13writeToBufferEP9SkWBuffer"]
    pub fn SkPathRef_writeToBuffer(this: *const SkPathRef, buffer: *mut SkWBuffer);
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkPathRef9writeSizeEv"]
    pub fn SkPathRef_writeSize(this: *const SkPathRef) -> u32;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkPathRef11interpolateERKS_fPS_"]
    pub fn SkPathRef_interpolate(
        this: *const SkPathRef,
        ending: *const SkPathRef,
        weight: SkScalar,
        out: *mut SkPathRef,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkPathRef5genIDEv"]
    pub fn SkPathRef_genID(this: *const SkPathRef) -> u32;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkPathRef22addGenIDChangeListenerE5sk_spINS_19GenIDChangeListenerEE"]
    pub fn SkPathRef_addGenIDChangeListener(
        this: *mut SkPathRef,
        arg1: sk_sp<SkPathRef_GenIDChangeListener>,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkPathRef7isValidEv"]
    pub fn SkPathRef_isValid(this: *const SkPathRef) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkPathRefD1Ev"]
    pub fn SkPathRef_SkPathRef_destructor(this: *mut SkPathRef);
}
impl SkPathRef {
    #[inline]
    pub unsafe fn CreateEmpty() -> *mut SkPathRef {
        SkPathRef_CreateEmpty()
    }
    #[inline]
    pub unsafe fn getRRect(&self) -> SkRRect {
        SkPathRef_getRRect(self)
    }
    #[inline]
    pub unsafe fn CreateTransformedCopy(
        dst: *mut sk_sp<SkPathRef>,
        src: *const SkPathRef,
        matrix: *const SkMatrix,
    ) {
        SkPathRef_CreateTransformedCopy(dst, src, matrix)
    }
    #[inline]
    pub unsafe fn CreateFromBuffer(buffer: *mut SkRBuffer) -> *mut SkPathRef {
        SkPathRef_CreateFromBuffer(buffer)
    }
    #[inline]
    pub unsafe fn Rewind(pathRef: *mut sk_sp<SkPathRef>) {
        SkPathRef_Rewind(pathRef)
    }
    #[inline]
    pub unsafe fn writeToBuffer(&self, buffer: *mut SkWBuffer) {
        SkPathRef_writeToBuffer(self, buffer)
    }
    #[inline]
    pub unsafe fn writeSize(&self) -> u32 {
        SkPathRef_writeSize(self)
    }
    #[inline]
    pub unsafe fn interpolate(
        &self,
        ending: *const SkPathRef,
        weight: SkScalar,
        out: *mut SkPathRef,
    ) {
        SkPathRef_interpolate(self, ending, weight, out)
    }
    #[inline]
    pub unsafe fn genID(&self) -> u32 {
        SkPathRef_genID(self)
    }
    #[inline]
    pub unsafe fn addGenIDChangeListener(&mut self, arg1: sk_sp<SkPathRef_GenIDChangeListener>) {
        SkPathRef_addGenIDChangeListener(self, arg1)
    }
    #[inline]
    pub unsafe fn isValid(&self) -> bool {
        SkPathRef_isValid(self)
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        SkPathRef_SkPathRef_destructor(self)
    }
}
#[repr(C)]
pub struct SkPath {
    pub fPathRef: sk_sp<SkPathRef>,
    pub fLastMoveToIndex: ::std::os::raw::c_int,
    pub fConvexity: u8,
    pub fFirstDirection: u8,
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
    pub __bindgen_padding_0: u8,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkPath_Direction {
    kCW_Direction = 0,
    kCCW_Direction = 1,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkPath_FillType {
    kWinding_FillType = 0,
    kEvenOdd_FillType = 1,
    kInverseWinding_FillType = 2,
    kInverseEvenOdd_FillType = 3,
}
#[repr(u8)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkPath_Convexity {
    kUnknown_Convexity = 0,
    kConvex_Convexity = 1,
    kConcave_Convexity = 2,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkPath_ArcSize {
    kSmall_ArcSize = 0,
    kLarge_ArcSize = 1,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkPath_AddPathMode {
    kAppend_AddPathMode = 0,
    kExtend_AddPathMode = 1,
}
pub const SkPath_SegmentMask_kLine_SegmentMask: SkPath_SegmentMask = 1;
pub const SkPath_SegmentMask_kQuad_SegmentMask: SkPath_SegmentMask = 2;
pub const SkPath_SegmentMask_kConic_SegmentMask: SkPath_SegmentMask = 4;
pub const SkPath_SegmentMask_kCubic_SegmentMask: SkPath_SegmentMask = 8;
pub type SkPath_SegmentMask = u32;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkPath_Verb {
    kMove_Verb = 0,
    kLine_Verb = 1,
    kQuad_Verb = 2,
    kConic_Verb = 3,
    kCubic_Verb = 4,
    kClose_Verb = 5,
    kDone_Verb = 6,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkPath_Iter {
    pub fPts: *const SkPoint,
    pub fVerbs: *const u8,
    pub fVerbStop: *const u8,
    pub fConicWeights: *const SkScalar,
    pub fMoveTo: SkPoint,
    pub fLastPt: SkPoint,
    pub fForceClose: bool,
    pub fNeedClose: bool,
    pub fCloseLine: bool,
    pub fSegmentState: SkPath_Iter_SegmentState,
}
#[repr(u8)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkPath_Iter_SegmentState {
    kEmptyContour_SegmentState = 0,
    kAfterMove_SegmentState = 1,
    kAfterPrimitive_SegmentState = 2,
}
#[test]
fn bindgen_test_layout_SkPath_Iter() {
    assert_eq!(
        ::core::mem::size_of::<SkPath_Iter>(),
        56usize,
        concat!("Size of: ", stringify!(SkPath_Iter))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPath_Iter>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPath_Iter))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPath_Iter>())).fPts as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPath_Iter),
            "::",
            stringify!(fPts)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPath_Iter>())).fVerbs as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPath_Iter),
            "::",
            stringify!(fVerbs)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPath_Iter>())).fVerbStop as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPath_Iter),
            "::",
            stringify!(fVerbStop)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPath_Iter>())).fConicWeights as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPath_Iter),
            "::",
            stringify!(fConicWeights)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPath_Iter>())).fMoveTo as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPath_Iter),
            "::",
            stringify!(fMoveTo)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPath_Iter>())).fLastPt as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPath_Iter),
            "::",
            stringify!(fLastPt)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPath_Iter>())).fForceClose as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPath_Iter),
            "::",
            stringify!(fForceClose)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPath_Iter>())).fNeedClose as *const _ as usize },
        49usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPath_Iter),
            "::",
            stringify!(fNeedClose)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPath_Iter>())).fCloseLine as *const _ as usize },
        50usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPath_Iter),
            "::",
            stringify!(fCloseLine)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPath_Iter>())).fSegmentState as *const _ as usize },
        51usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPath_Iter),
            "::",
            stringify!(fSegmentState)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath4Iter7setPathERKS_b"]
    pub fn SkPath_Iter_setPath(this: *mut SkPath_Iter, path: *const SkPath, forceClose: bool);
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath4Iter15isClosedContourEv"]
    pub fn SkPath_Iter_isClosedContour(this: *const SkPath_Iter) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath4IterC1Ev"]
    pub fn SkPath_Iter_Iter(this: *mut SkPath_Iter);
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath4IterC1ERKS_b"]
    pub fn SkPath_Iter_Iter1(this: *mut SkPath_Iter, path: *const SkPath, forceClose: bool);
}
impl SkPath_Iter {
    #[inline]
    pub unsafe fn setPath(&mut self, path: *const SkPath, forceClose: bool) {
        SkPath_Iter_setPath(self, path, forceClose)
    }
    #[inline]
    pub unsafe fn isClosedContour(&self) -> bool {
        SkPath_Iter_isClosedContour(self)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkPath_Iter_Iter(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(path: *const SkPath, forceClose: bool) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkPath_Iter_Iter1(&mut __bindgen_tmp, path, forceClose);
        __bindgen_tmp
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkPath_RawIter {
    pub fRawIter: SkPathRef_Iter,
}
#[test]
fn bindgen_test_layout_SkPath_RawIter() {
    assert_eq!(
        ::core::mem::size_of::<SkPath_RawIter>(),
        32usize,
        concat!("Size of: ", stringify!(SkPath_RawIter))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPath_RawIter>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPath_RawIter))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPath_RawIter>())).fRawIter as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPath_RawIter),
            "::",
            stringify!(fRawIter)
        )
    );
}
#[test]
fn bindgen_test_layout_SkPath() {
    assert_eq!(
        ::core::mem::size_of::<SkPath>(),
        16usize,
        concat!("Size of: ", stringify!(SkPath))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPath>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPath))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPath>())).fPathRef as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPath),
            "::",
            stringify!(fPathRef)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPath>())).fLastMoveToIndex as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPath),
            "::",
            stringify!(fLastMoveToIndex)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPath>())).fConvexity as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPath),
            "::",
            stringify!(fConvexity)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPath>())).fFirstDirection as *const _ as usize },
        13usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPath),
            "::",
            stringify!(fFirstDirection)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath16isInterpolatableERKS_"]
    pub fn SkPath_isInterpolatable(this: *const SkPath, compare: *const SkPath) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath11interpolateERKS_fPS_"]
    pub fn SkPath_interpolate(
        this: *const SkPath,
        ending: *const SkPath,
        weight: SkScalar,
        out: *mut SkPath,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath12setConvexityENS_9ConvexityE"]
    pub fn SkPath_setConvexity(this: *mut SkPath, convexity: SkPath_Convexity);
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath6isOvalEP6SkRect"]
    pub fn SkPath_isOval(this: *const SkPath, bounds: *mut SkRect) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath7isRRectEP7SkRRect"]
    pub fn SkPath_isRRect(this: *const SkPath, rrect: *mut SkRRect) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath5resetEv"]
    pub fn SkPath_reset(this: *mut SkPath) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath6rewindEv"]
    pub fn SkPath_rewind(this: *mut SkPath) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath19isLastContourClosedEv"]
    pub fn SkPath_isLastContourClosed(this: *const SkPath) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath16IsLineDegenerateERK7SkPointS2_b"]
    pub fn SkPath_IsLineDegenerate(p1: *const SkPoint, p2: *const SkPoint, exact: bool) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath16IsQuadDegenerateERK7SkPointS2_S2_b"]
    pub fn SkPath_IsQuadDegenerate(
        p1: *const SkPoint,
        p2: *const SkPoint,
        p3: *const SkPoint,
        exact: bool,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath17IsCubicDegenerateERK7SkPointS2_S2_S2_b"]
    pub fn SkPath_IsCubicDegenerate(
        p1: *const SkPoint,
        p2: *const SkPoint,
        p3: *const SkPoint,
        p4: *const SkPoint,
        exact: bool,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath6isLineEP7SkPoint"]
    pub fn SkPath_isLine(this: *const SkPath, line: *mut SkPoint) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath11countPointsEv"]
    pub fn SkPath_countPoints(this: *const SkPath) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath8getPointEi"]
    pub fn SkPath_getPoint(this: *const SkPath, index: ::std::os::raw::c_int) -> SkPoint;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath9getPointsEP7SkPointi"]
    pub fn SkPath_getPoints(
        this: *const SkPath,
        points: *mut SkPoint,
        max: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath10countVerbsEv"]
    pub fn SkPath_countVerbs(this: *const SkPath) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath8getVerbsEPhi"]
    pub fn SkPath_getVerbs(
        this: *const SkPath,
        verbs: *mut u8,
        max: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath20approximateBytesUsedEv"]
    pub fn SkPath_approximateBytesUsed(this: *const SkPath) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath4swapERS_"]
    pub fn SkPath_swap(this: *mut SkPath, other: *mut SkPath);
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath18computeTightBoundsEv"]
    pub fn SkPath_computeTightBounds(this: *const SkPath) -> SkRect;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath26conservativelyContainsRectERK6SkRect"]
    pub fn SkPath_conservativelyContainsRect(this: *const SkPath, rect: *const SkRect) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath10incReserveEi"]
    pub fn SkPath_incReserve(this: *mut SkPath, extraPtCount: ::std::os::raw::c_int);
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath11shrinkToFitEv"]
    pub fn SkPath_shrinkToFit(this: *mut SkPath);
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath6moveToEff"]
    pub fn SkPath_moveTo(this: *mut SkPath, x: SkScalar, y: SkScalar) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath7rMoveToEff"]
    pub fn SkPath_rMoveTo(this: *mut SkPath, dx: SkScalar, dy: SkScalar) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath6lineToEff"]
    pub fn SkPath_lineTo(this: *mut SkPath, x: SkScalar, y: SkScalar) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath7rLineToEff"]
    pub fn SkPath_rLineTo(this: *mut SkPath, dx: SkScalar, dy: SkScalar) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath6quadToEffff"]
    pub fn SkPath_quadTo(
        this: *mut SkPath,
        x1: SkScalar,
        y1: SkScalar,
        x2: SkScalar,
        y2: SkScalar,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath7rQuadToEffff"]
    pub fn SkPath_rQuadTo(
        this: *mut SkPath,
        dx1: SkScalar,
        dy1: SkScalar,
        dx2: SkScalar,
        dy2: SkScalar,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath7conicToEfffff"]
    pub fn SkPath_conicTo(
        this: *mut SkPath,
        x1: SkScalar,
        y1: SkScalar,
        x2: SkScalar,
        y2: SkScalar,
        w: SkScalar,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath8rConicToEfffff"]
    pub fn SkPath_rConicTo(
        this: *mut SkPath,
        dx1: SkScalar,
        dy1: SkScalar,
        dx2: SkScalar,
        dy2: SkScalar,
        w: SkScalar,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath7cubicToEffffff"]
    pub fn SkPath_cubicTo(
        this: *mut SkPath,
        x1: SkScalar,
        y1: SkScalar,
        x2: SkScalar,
        y2: SkScalar,
        x3: SkScalar,
        y3: SkScalar,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath8rCubicToEffffff"]
    pub fn SkPath_rCubicTo(
        this: *mut SkPath,
        dx1: SkScalar,
        dy1: SkScalar,
        dx2: SkScalar,
        dy2: SkScalar,
        dx3: SkScalar,
        dy3: SkScalar,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath5arcToERK6SkRectffb"]
    pub fn SkPath_arcTo(
        this: *mut SkPath,
        oval: *const SkRect,
        startAngle: SkScalar,
        sweepAngle: SkScalar,
        forceMoveTo: bool,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath5arcToEfffff"]
    pub fn SkPath_arcTo1(
        this: *mut SkPath,
        x1: SkScalar,
        y1: SkScalar,
        x2: SkScalar,
        y2: SkScalar,
        radius: SkScalar,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath5arcToEfffNS_7ArcSizeENS_9DirectionEff"]
    pub fn SkPath_arcTo2(
        this: *mut SkPath,
        rx: SkScalar,
        ry: SkScalar,
        xAxisRotate: SkScalar,
        largeArc: SkPath_ArcSize,
        sweep: SkPath_Direction,
        x: SkScalar,
        y: SkScalar,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath6rArcToEfffNS_7ArcSizeENS_9DirectionEff"]
    pub fn SkPath_rArcTo(
        this: *mut SkPath,
        rx: SkScalar,
        ry: SkScalar,
        xAxisRotate: SkScalar,
        largeArc: SkPath_ArcSize,
        sweep: SkPath_Direction,
        dx: SkScalar,
        dy: SkScalar,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath5closeEv"]
    pub fn SkPath_close(this: *mut SkPath) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath19ConvertConicToQuadsERK7SkPointS2_S2_fPS0_i"]
    pub fn SkPath_ConvertConicToQuads(
        p0: *const SkPoint,
        p1: *const SkPoint,
        p2: *const SkPoint,
        w: SkScalar,
        pts: *mut SkPoint,
        pow2: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath6isRectEP6SkRectPbPNS_9DirectionE"]
    pub fn SkPath_isRect(
        this: *const SkPath,
        rect: *mut SkRect,
        isClosed: *mut bool,
        direction: *mut SkPath_Direction,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath17isNestedFillRectsEP6SkRectPNS_9DirectionE"]
    pub fn SkPath_isNestedFillRects(
        this: *const SkPath,
        rect: *mut SkRect,
        dirs: *mut SkPath_Direction,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath7addRectERK6SkRectNS_9DirectionE"]
    pub fn SkPath_addRect(
        this: *mut SkPath,
        rect: *const SkRect,
        dir: SkPath_Direction,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath7addRectERK6SkRectNS_9DirectionEj"]
    pub fn SkPath_addRect1(
        this: *mut SkPath,
        rect: *const SkRect,
        dir: SkPath_Direction,
        start: ::std::os::raw::c_uint,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath7addRectEffffNS_9DirectionE"]
    pub fn SkPath_addRect2(
        this: *mut SkPath,
        left: SkScalar,
        top: SkScalar,
        right: SkScalar,
        bottom: SkScalar,
        dir: SkPath_Direction,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath7addOvalERK6SkRectNS_9DirectionE"]
    pub fn SkPath_addOval(
        this: *mut SkPath,
        oval: *const SkRect,
        dir: SkPath_Direction,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath7addOvalERK6SkRectNS_9DirectionEj"]
    pub fn SkPath_addOval1(
        this: *mut SkPath,
        oval: *const SkRect,
        dir: SkPath_Direction,
        start: ::std::os::raw::c_uint,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath9addCircleEfffNS_9DirectionE"]
    pub fn SkPath_addCircle(
        this: *mut SkPath,
        x: SkScalar,
        y: SkScalar,
        radius: SkScalar,
        dir: SkPath_Direction,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath6addArcERK6SkRectff"]
    pub fn SkPath_addArc(
        this: *mut SkPath,
        oval: *const SkRect,
        startAngle: SkScalar,
        sweepAngle: SkScalar,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath12addRoundRectERK6SkRectffNS_9DirectionE"]
    pub fn SkPath_addRoundRect(
        this: *mut SkPath,
        rect: *const SkRect,
        rx: SkScalar,
        ry: SkScalar,
        dir: SkPath_Direction,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath12addRoundRectERK6SkRectPKfNS_9DirectionE"]
    pub fn SkPath_addRoundRect1(
        this: *mut SkPath,
        rect: *const SkRect,
        radii: *const SkScalar,
        dir: SkPath_Direction,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath8addRRectERK7SkRRectNS_9DirectionE"]
    pub fn SkPath_addRRect(
        this: *mut SkPath,
        rrect: *const SkRRect,
        dir: SkPath_Direction,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath8addRRectERK7SkRRectNS_9DirectionEj"]
    pub fn SkPath_addRRect1(
        this: *mut SkPath,
        rrect: *const SkRRect,
        dir: SkPath_Direction,
        start: ::std::os::raw::c_uint,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath7addPolyEPK7SkPointib"]
    pub fn SkPath_addPoly(
        this: *mut SkPath,
        pts: *const SkPoint,
        count: ::std::os::raw::c_int,
        close: bool,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath7addPathERKS_ffNS_11AddPathModeE"]
    pub fn SkPath_addPath(
        this: *mut SkPath,
        src: *const SkPath,
        dx: SkScalar,
        dy: SkScalar,
        mode: SkPath_AddPathMode,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath7addPathERKS_RK8SkMatrixNS_11AddPathModeE"]
    pub fn SkPath_addPath1(
        this: *mut SkPath,
        src: *const SkPath,
        matrix: *const SkMatrix,
        mode: SkPath_AddPathMode,
    ) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath14reverseAddPathERKS_"]
    pub fn SkPath_reverseAddPath(this: *mut SkPath, src: *const SkPath) -> *mut SkPath;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath6offsetEffPS_"]
    pub fn SkPath_offset(this: *const SkPath, dx: SkScalar, dy: SkScalar, dst: *mut SkPath);
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath9transformERK8SkMatrixPS_"]
    pub fn SkPath_transform(this: *const SkPath, matrix: *const SkMatrix, dst: *mut SkPath);
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath9getLastPtEP7SkPoint"]
    pub fn SkPath_getLastPt(this: *const SkPath, lastPt: *mut SkPoint) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath9setLastPtEff"]
    pub fn SkPath_setLastPt(this: *mut SkPath, x: SkScalar, y: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath8containsEff"]
    pub fn SkPath_contains(this: *const SkPath, x: SkScalar, y: SkScalar) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath4dumpEP9SkWStreambb"]
    pub fn SkPath_dump(
        this: *const SkPath,
        stream: *mut SkWStream,
        forceClose: bool,
        dumpAsHex: bool,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath4dumpEv"]
    pub fn SkPath_dump1(this: *const SkPath);
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath7dumpHexEv"]
    pub fn SkPath_dumpHex(this: *const SkPath);
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath13writeToMemoryEPv"]
    pub fn SkPath_writeToMemory(this: *const SkPath, buffer: *mut ::std::os::raw::c_void) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath9serializeEv"]
    pub fn SkPath_serialize(this: *const SkPath) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPath14readFromMemoryEPKvm"]
    pub fn SkPath_readFromMemory(
        this: *mut SkPath,
        buffer: *const ::std::os::raw::c_void,
        length: usize,
    ) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkPath15getGenerationIDEv"]
    pub fn SkPath_getGenerationID(this: *const SkPath) -> u32;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPathC1Ev"]
    pub fn SkPath_SkPath(this: *mut SkPath);
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPathC1ERKS_"]
    pub fn SkPath_SkPath1(this: *mut SkPath, path: *const SkPath);
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkPathD1Ev"]
    pub fn SkPath_SkPath_destructor(this: *mut SkPath);
}
impl SkPath {
    #[inline]
    pub fn fFillType(&self) -> u8 {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u8) }
    }
    #[inline]
    pub fn set_fFillType(&mut self, val: u8) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            self._bitfield_1.set(0usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub fn fIsVolatile(&self) -> u8 {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
    }
    #[inline]
    pub fn set_fIsVolatile(&mut self, val: u8) {
        unsafe {
            let val: u8 = ::core::mem::transmute(val);
            self._bitfield_1.set(2usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        fFillType: u8,
        fIsVolatile: u8,
    ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 2u8, {
            let fFillType: u8 = unsafe { ::core::mem::transmute(fFillType) };
            fFillType as u64
        });
        __bindgen_bitfield_unit.set(2usize, 1u8, {
            let fIsVolatile: u8 = unsafe { ::core::mem::transmute(fIsVolatile) };
            fIsVolatile as u64
        });
        __bindgen_bitfield_unit
    }
    #[inline]
    pub unsafe fn isInterpolatable(&self, compare: *const SkPath) -> bool {
        SkPath_isInterpolatable(self, compare)
    }
    #[inline]
    pub unsafe fn interpolate(
        &self,
        ending: *const SkPath,
        weight: SkScalar,
        out: *mut SkPath,
    ) -> bool {
        SkPath_interpolate(self, ending, weight, out)
    }
    #[inline]
    pub unsafe fn setConvexity(&mut self, convexity: SkPath_Convexity) {
        SkPath_setConvexity(self, convexity)
    }
    #[inline]
    pub unsafe fn isOval(&self, bounds: *mut SkRect) -> bool {
        SkPath_isOval(self, bounds)
    }
    #[inline]
    pub unsafe fn isRRect(&self, rrect: *mut SkRRect) -> bool {
        SkPath_isRRect(self, rrect)
    }
    #[inline]
    pub unsafe fn reset(&mut self) -> *mut SkPath {
        SkPath_reset(self)
    }
    #[inline]
    pub unsafe fn rewind(&mut self) -> *mut SkPath {
        SkPath_rewind(self)
    }
    #[inline]
    pub unsafe fn isLastContourClosed(&self) -> bool {
        SkPath_isLastContourClosed(self)
    }
    #[inline]
    pub unsafe fn IsLineDegenerate(p1: *const SkPoint, p2: *const SkPoint, exact: bool) -> bool {
        SkPath_IsLineDegenerate(p1, p2, exact)
    }
    #[inline]
    pub unsafe fn IsQuadDegenerate(
        p1: *const SkPoint,
        p2: *const SkPoint,
        p3: *const SkPoint,
        exact: bool,
    ) -> bool {
        SkPath_IsQuadDegenerate(p1, p2, p3, exact)
    }
    #[inline]
    pub unsafe fn IsCubicDegenerate(
        p1: *const SkPoint,
        p2: *const SkPoint,
        p3: *const SkPoint,
        p4: *const SkPoint,
        exact: bool,
    ) -> bool {
        SkPath_IsCubicDegenerate(p1, p2, p3, p4, exact)
    }
    #[inline]
    pub unsafe fn isLine(&self, line: *mut SkPoint) -> bool {
        SkPath_isLine(self, line)
    }
    #[inline]
    pub unsafe fn countPoints(&self) -> ::std::os::raw::c_int {
        SkPath_countPoints(self)
    }
    #[inline]
    pub unsafe fn getPoint(&self, index: ::std::os::raw::c_int) -> SkPoint {
        SkPath_getPoint(self, index)
    }
    #[inline]
    pub unsafe fn getPoints(
        &self,
        points: *mut SkPoint,
        max: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        SkPath_getPoints(self, points, max)
    }
    #[inline]
    pub unsafe fn countVerbs(&self) -> ::std::os::raw::c_int {
        SkPath_countVerbs(self)
    }
    #[inline]
    pub unsafe fn getVerbs(
        &self,
        verbs: *mut u8,
        max: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        SkPath_getVerbs(self, verbs, max)
    }
    #[inline]
    pub unsafe fn approximateBytesUsed(&self) -> usize {
        SkPath_approximateBytesUsed(self)
    }
    #[inline]
    pub unsafe fn swap(&mut self, other: *mut SkPath) {
        SkPath_swap(self, other)
    }
    #[inline]
    pub unsafe fn computeTightBounds(&self) -> SkRect {
        SkPath_computeTightBounds(self)
    }
    #[inline]
    pub unsafe fn conservativelyContainsRect(&self, rect: *const SkRect) -> bool {
        SkPath_conservativelyContainsRect(self, rect)
    }
    #[inline]
    pub unsafe fn incReserve(&mut self, extraPtCount: ::std::os::raw::c_int) {
        SkPath_incReserve(self, extraPtCount)
    }
    #[inline]
    pub unsafe fn shrinkToFit(&mut self) {
        SkPath_shrinkToFit(self)
    }
    #[inline]
    pub unsafe fn moveTo(&mut self, x: SkScalar, y: SkScalar) -> *mut SkPath {
        SkPath_moveTo(self, x, y)
    }
    #[inline]
    pub unsafe fn rMoveTo(&mut self, dx: SkScalar, dy: SkScalar) -> *mut SkPath {
        SkPath_rMoveTo(self, dx, dy)
    }
    #[inline]
    pub unsafe fn lineTo(&mut self, x: SkScalar, y: SkScalar) -> *mut SkPath {
        SkPath_lineTo(self, x, y)
    }
    #[inline]
    pub unsafe fn rLineTo(&mut self, dx: SkScalar, dy: SkScalar) -> *mut SkPath {
        SkPath_rLineTo(self, dx, dy)
    }
    #[inline]
    pub unsafe fn quadTo(
        &mut self,
        x1: SkScalar,
        y1: SkScalar,
        x2: SkScalar,
        y2: SkScalar,
    ) -> *mut SkPath {
        SkPath_quadTo(self, x1, y1, x2, y2)
    }
    #[inline]
    pub unsafe fn rQuadTo(
        &mut self,
        dx1: SkScalar,
        dy1: SkScalar,
        dx2: SkScalar,
        dy2: SkScalar,
    ) -> *mut SkPath {
        SkPath_rQuadTo(self, dx1, dy1, dx2, dy2)
    }
    #[inline]
    pub unsafe fn conicTo(
        &mut self,
        x1: SkScalar,
        y1: SkScalar,
        x2: SkScalar,
        y2: SkScalar,
        w: SkScalar,
    ) -> *mut SkPath {
        SkPath_conicTo(self, x1, y1, x2, y2, w)
    }
    #[inline]
    pub unsafe fn rConicTo(
        &mut self,
        dx1: SkScalar,
        dy1: SkScalar,
        dx2: SkScalar,
        dy2: SkScalar,
        w: SkScalar,
    ) -> *mut SkPath {
        SkPath_rConicTo(self, dx1, dy1, dx2, dy2, w)
    }
    #[inline]
    pub unsafe fn cubicTo(
        &mut self,
        x1: SkScalar,
        y1: SkScalar,
        x2: SkScalar,
        y2: SkScalar,
        x3: SkScalar,
        y3: SkScalar,
    ) -> *mut SkPath {
        SkPath_cubicTo(self, x1, y1, x2, y2, x3, y3)
    }
    #[inline]
    pub unsafe fn rCubicTo(
        &mut self,
        dx1: SkScalar,
        dy1: SkScalar,
        dx2: SkScalar,
        dy2: SkScalar,
        dx3: SkScalar,
        dy3: SkScalar,
    ) -> *mut SkPath {
        SkPath_rCubicTo(self, dx1, dy1, dx2, dy2, dx3, dy3)
    }
    #[inline]
    pub unsafe fn arcTo(
        &mut self,
        oval: *const SkRect,
        startAngle: SkScalar,
        sweepAngle: SkScalar,
        forceMoveTo: bool,
    ) -> *mut SkPath {
        SkPath_arcTo(self, oval, startAngle, sweepAngle, forceMoveTo)
    }
    #[inline]
    pub unsafe fn arcTo1(
        &mut self,
        x1: SkScalar,
        y1: SkScalar,
        x2: SkScalar,
        y2: SkScalar,
        radius: SkScalar,
    ) -> *mut SkPath {
        SkPath_arcTo1(self, x1, y1, x2, y2, radius)
    }
    #[inline]
    pub unsafe fn arcTo2(
        &mut self,
        rx: SkScalar,
        ry: SkScalar,
        xAxisRotate: SkScalar,
        largeArc: SkPath_ArcSize,
        sweep: SkPath_Direction,
        x: SkScalar,
        y: SkScalar,
    ) -> *mut SkPath {
        SkPath_arcTo2(self, rx, ry, xAxisRotate, largeArc, sweep, x, y)
    }
    #[inline]
    pub unsafe fn rArcTo(
        &mut self,
        rx: SkScalar,
        ry: SkScalar,
        xAxisRotate: SkScalar,
        largeArc: SkPath_ArcSize,
        sweep: SkPath_Direction,
        dx: SkScalar,
        dy: SkScalar,
    ) -> *mut SkPath {
        SkPath_rArcTo(self, rx, ry, xAxisRotate, largeArc, sweep, dx, dy)
    }
    #[inline]
    pub unsafe fn close(&mut self) -> *mut SkPath {
        SkPath_close(self)
    }
    #[inline]
    pub unsafe fn ConvertConicToQuads(
        p0: *const SkPoint,
        p1: *const SkPoint,
        p2: *const SkPoint,
        w: SkScalar,
        pts: *mut SkPoint,
        pow2: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        SkPath_ConvertConicToQuads(p0, p1, p2, w, pts, pow2)
    }
    #[inline]
    pub unsafe fn isRect(
        &self,
        rect: *mut SkRect,
        isClosed: *mut bool,
        direction: *mut SkPath_Direction,
    ) -> bool {
        SkPath_isRect(self, rect, isClosed, direction)
    }
    #[inline]
    pub unsafe fn isNestedFillRects(&self, rect: *mut SkRect, dirs: *mut SkPath_Direction) -> bool {
        SkPath_isNestedFillRects(self, rect, dirs)
    }
    #[inline]
    pub unsafe fn addRect(&mut self, rect: *const SkRect, dir: SkPath_Direction) -> *mut SkPath {
        SkPath_addRect(self, rect, dir)
    }
    #[inline]
    pub unsafe fn addRect1(
        &mut self,
        rect: *const SkRect,
        dir: SkPath_Direction,
        start: ::std::os::raw::c_uint,
    ) -> *mut SkPath {
        SkPath_addRect1(self, rect, dir, start)
    }
    #[inline]
    pub unsafe fn addRect2(
        &mut self,
        left: SkScalar,
        top: SkScalar,
        right: SkScalar,
        bottom: SkScalar,
        dir: SkPath_Direction,
    ) -> *mut SkPath {
        SkPath_addRect2(self, left, top, right, bottom, dir)
    }
    #[inline]
    pub unsafe fn addOval(&mut self, oval: *const SkRect, dir: SkPath_Direction) -> *mut SkPath {
        SkPath_addOval(self, oval, dir)
    }
    #[inline]
    pub unsafe fn addOval1(
        &mut self,
        oval: *const SkRect,
        dir: SkPath_Direction,
        start: ::std::os::raw::c_uint,
    ) -> *mut SkPath {
        SkPath_addOval1(self, oval, dir, start)
    }
    #[inline]
    pub unsafe fn addCircle(
        &mut self,
        x: SkScalar,
        y: SkScalar,
        radius: SkScalar,
        dir: SkPath_Direction,
    ) -> *mut SkPath {
        SkPath_addCircle(self, x, y, radius, dir)
    }
    #[inline]
    pub unsafe fn addArc(
        &mut self,
        oval: *const SkRect,
        startAngle: SkScalar,
        sweepAngle: SkScalar,
    ) -> *mut SkPath {
        SkPath_addArc(self, oval, startAngle, sweepAngle)
    }
    #[inline]
    pub unsafe fn addRoundRect(
        &mut self,
        rect: *const SkRect,
        rx: SkScalar,
        ry: SkScalar,
        dir: SkPath_Direction,
    ) -> *mut SkPath {
        SkPath_addRoundRect(self, rect, rx, ry, dir)
    }
    #[inline]
    pub unsafe fn addRoundRect1(
        &mut self,
        rect: *const SkRect,
        radii: *const SkScalar,
        dir: SkPath_Direction,
    ) -> *mut SkPath {
        SkPath_addRoundRect1(self, rect, radii, dir)
    }
    #[inline]
    pub unsafe fn addRRect(&mut self, rrect: *const SkRRect, dir: SkPath_Direction) -> *mut SkPath {
        SkPath_addRRect(self, rrect, dir)
    }
    #[inline]
    pub unsafe fn addRRect1(
        &mut self,
        rrect: *const SkRRect,
        dir: SkPath_Direction,
        start: ::std::os::raw::c_uint,
    ) -> *mut SkPath {
        SkPath_addRRect1(self, rrect, dir, start)
    }
    #[inline]
    pub unsafe fn addPoly(
        &mut self,
        pts: *const SkPoint,
        count: ::std::os::raw::c_int,
        close: bool,
    ) -> *mut SkPath {
        SkPath_addPoly(self, pts, count, close)
    }
    #[inline]
    pub unsafe fn addPath(
        &mut self,
        src: *const SkPath,
        dx: SkScalar,
        dy: SkScalar,
        mode: SkPath_AddPathMode,
    ) -> *mut SkPath {
        SkPath_addPath(self, src, dx, dy, mode)
    }
    #[inline]
    pub unsafe fn addPath1(
        &mut self,
        src: *const SkPath,
        matrix: *const SkMatrix,
        mode: SkPath_AddPathMode,
    ) -> *mut SkPath {
        SkPath_addPath1(self, src, matrix, mode)
    }
    #[inline]
    pub unsafe fn reverseAddPath(&mut self, src: *const SkPath) -> *mut SkPath {
        SkPath_reverseAddPath(self, src)
    }
    #[inline]
    pub unsafe fn offset(&self, dx: SkScalar, dy: SkScalar, dst: *mut SkPath) {
        SkPath_offset(self, dx, dy, dst)
    }
    #[inline]
    pub unsafe fn transform(&self, matrix: *const SkMatrix, dst: *mut SkPath) {
        SkPath_transform(self, matrix, dst)
    }
    #[inline]
    pub unsafe fn getLastPt(&self, lastPt: *mut SkPoint) -> bool {
        SkPath_getLastPt(self, lastPt)
    }
    #[inline]
    pub unsafe fn setLastPt(&mut self, x: SkScalar, y: SkScalar) {
        SkPath_setLastPt(self, x, y)
    }
    #[inline]
    pub unsafe fn contains(&self, x: SkScalar, y: SkScalar) -> bool {
        SkPath_contains(self, x, y)
    }
    #[inline]
    pub unsafe fn dump(&self, stream: *mut SkWStream, forceClose: bool, dumpAsHex: bool) {
        SkPath_dump(self, stream, forceClose, dumpAsHex)
    }
    #[inline]
    pub unsafe fn dump1(&self) {
        SkPath_dump1(self)
    }
    #[inline]
    pub unsafe fn dumpHex(&self) {
        SkPath_dumpHex(self)
    }
    #[inline]
    pub unsafe fn writeToMemory(&self, buffer: *mut ::std::os::raw::c_void) -> usize {
        SkPath_writeToMemory(self, buffer)
    }
    #[inline]
    pub unsafe fn serialize(&self) -> sk_sp<SkData> {
        SkPath_serialize(self)
    }
    #[inline]
    pub unsafe fn readFromMemory(
        &mut self,
        buffer: *const ::std::os::raw::c_void,
        length: usize,
    ) -> usize {
        SkPath_readFromMemory(self, buffer, length)
    }
    #[inline]
    pub unsafe fn getGenerationID(&self) -> u32 {
        SkPath_getGenerationID(self)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkPath_SkPath(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(path: *const SkPath) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkPath_SkPath1(&mut __bindgen_tmp, path);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        SkPath_SkPath_destructor(self)
    }
}
#[repr(C)]
pub struct SkContourMeasure {
    pub _base: SkRefCnt,
    pub fSegments: SkTDArray<SkContourMeasure_Segment>,
    pub fPts: SkTDArray<SkPoint>,
    pub fLength: SkScalar,
    pub fIsClosed: bool,
}
pub const SkContourMeasure_MatrixFlags_kGetPosition_MatrixFlag: SkContourMeasure_MatrixFlags = 1;
pub const SkContourMeasure_MatrixFlags_kGetTangent_MatrixFlag: SkContourMeasure_MatrixFlags = 2;
pub const SkContourMeasure_MatrixFlags_kGetPosAndTan_MatrixFlag: SkContourMeasure_MatrixFlags = 3;
pub type SkContourMeasure_MatrixFlags = u32;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkContourMeasure_Segment {
    pub fDistance: SkScalar,
    pub fPtIndex: ::std::os::raw::c_uint,
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>,
}
#[test]
fn bindgen_test_layout_SkContourMeasure_Segment() {
    assert_eq!(
        ::core::mem::size_of::<SkContourMeasure_Segment>(),
        12usize,
        concat!("Size of: ", stringify!(SkContourMeasure_Segment))
    );
    assert_eq!(
        ::core::mem::align_of::<SkContourMeasure_Segment>(),
        4usize,
        concat!("Alignment of ", stringify!(SkContourMeasure_Segment))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkContourMeasure_Segment>())).fDistance as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkContourMeasure_Segment),
            "::",
            stringify!(fDistance)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkContourMeasure_Segment>())).fPtIndex as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkContourMeasure_Segment),
            "::",
            stringify!(fPtIndex)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK16SkContourMeasure7Segment10getScalarTEv"]
    pub fn SkContourMeasure_Segment_getScalarT(this: *const SkContourMeasure_Segment) -> SkScalar;
}
impl SkContourMeasure_Segment {
    #[inline]
    pub fn fTValue(&self) -> ::std::os::raw::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 30u8) as u32) }
    }
    #[inline]
    pub fn set_fTValue(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(0usize, 30u8, val as u64)
        }
    }
    #[inline]
    pub fn fType(&self) -> ::std::os::raw::c_uint {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(30usize, 2u8) as u32) }
    }
    #[inline]
    pub fn set_fType(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(30usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        fTValue: ::std::os::raw::c_uint,
        fType: ::std::os::raw::c_uint,
    ) -> __BindgenBitfieldUnit<[u8; 4usize], u32> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u32> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 30u8, {
            let fTValue: u32 = unsafe { ::core::mem::transmute(fTValue) };
            fTValue as u64
        });
        __bindgen_bitfield_unit.set(30usize, 2u8, {
            let fType: u32 = unsafe { ::core::mem::transmute(fType) };
            fType as u64
        });
        __bindgen_bitfield_unit
    }
    #[inline]
    pub unsafe fn getScalarT(&self) -> SkScalar {
        SkContourMeasure_Segment_getScalarT(self)
    }
}
#[test]
fn bindgen_test_layout_SkContourMeasure() {
    assert_eq!(
        ::core::mem::size_of::<SkContourMeasure>(),
        56usize,
        concat!("Size of: ", stringify!(SkContourMeasure))
    );
    assert_eq!(
        ::core::mem::align_of::<SkContourMeasure>(),
        8usize,
        concat!("Alignment of ", stringify!(SkContourMeasure))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkContourMeasure>())).fSegments as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkContourMeasure),
            "::",
            stringify!(fSegments)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkContourMeasure>())).fPts as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(SkContourMeasure),
            "::",
            stringify!(fPts)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkContourMeasure>())).fLength as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(SkContourMeasure),
            "::",
            stringify!(fLength)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkContourMeasure>())).fIsClosed as *const _ as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(SkContourMeasure),
            "::",
            stringify!(fIsClosed)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK16SkContourMeasure9getPosTanEfP7SkPointS1_"]
    pub fn SkContourMeasure_getPosTan(
        this: *const SkContourMeasure,
        distance: SkScalar,
        position: *mut SkPoint,
        tangent: *mut SkVector,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK16SkContourMeasure9getMatrixEfP8SkMatrixNS_11MatrixFlagsE"]
    pub fn SkContourMeasure_getMatrix(
        this: *const SkContourMeasure,
        distance: SkScalar,
        matrix: *mut SkMatrix,
        flags: SkContourMeasure_MatrixFlags,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK16SkContourMeasure10getSegmentEffP6SkPathb"]
    pub fn SkContourMeasure_getSegment(
        this: *const SkContourMeasure,
        startD: SkScalar,
        stopD: SkScalar,
        dst: *mut SkPath,
        startWithMoveTo: bool,
    ) -> bool;
}
impl SkContourMeasure {
    #[inline]
    pub unsafe fn getPosTan(
        &self,
        distance: SkScalar,
        position: *mut SkPoint,
        tangent: *mut SkVector,
    ) -> bool {
        SkContourMeasure_getPosTan(self, distance, position, tangent)
    }
    #[inline]
    pub unsafe fn getMatrix(
        &self,
        distance: SkScalar,
        matrix: *mut SkMatrix,
        flags: SkContourMeasure_MatrixFlags,
    ) -> bool {
        SkContourMeasure_getMatrix(self, distance, matrix, flags)
    }
    #[inline]
    pub unsafe fn getSegment(
        &self,
        startD: SkScalar,
        stopD: SkScalar,
        dst: *mut SkPath,
        startWithMoveTo: bool,
    ) -> bool {
        SkContourMeasure_getSegment(self, startD, stopD, dst, startWithMoveTo)
    }
}
#[repr(C)]
pub struct SkContourMeasureIter {
    pub fIter: SkPath_RawIter,
    pub fPath: SkPath,
    pub fTolerance: SkScalar,
    pub fForceClosed: bool,
    pub fSegments: SkTDArray<SkContourMeasure_Segment>,
    pub fPts: SkTDArray<SkPoint>,
}
#[test]
fn bindgen_test_layout_SkContourMeasureIter() {
    assert_eq!(
        ::core::mem::size_of::<SkContourMeasureIter>(),
        88usize,
        concat!("Size of: ", stringify!(SkContourMeasureIter))
    );
    assert_eq!(
        ::core::mem::align_of::<SkContourMeasureIter>(),
        8usize,
        concat!("Alignment of ", stringify!(SkContourMeasureIter))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkContourMeasureIter>())).fIter as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkContourMeasureIter),
            "::",
            stringify!(fIter)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkContourMeasureIter>())).fPath as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(SkContourMeasureIter),
            "::",
            stringify!(fPath)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkContourMeasureIter>())).fTolerance as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(SkContourMeasureIter),
            "::",
            stringify!(fTolerance)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkContourMeasureIter>())).fForceClosed as *const _ as usize
        },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(SkContourMeasureIter),
            "::",
            stringify!(fForceClosed)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkContourMeasureIter>())).fSegments as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(SkContourMeasureIter),
            "::",
            stringify!(fSegments)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkContourMeasureIter>())).fPts as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(SkContourMeasureIter),
            "::",
            stringify!(fPts)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN20SkContourMeasureIter5resetERK6SkPathbf"]
    pub fn SkContourMeasureIter_reset(
        this: *mut SkContourMeasureIter,
        path: *const SkPath,
        forceClosed: bool,
        resScale: SkScalar,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN20SkContourMeasureIter4nextEv"]
    pub fn SkContourMeasureIter_next(this: *mut SkContourMeasureIter) -> sk_sp<SkContourMeasure>;
}
extern "C" {
    #[link_name = "\u{1}_ZN20SkContourMeasureIterC1Ev"]
    pub fn SkContourMeasureIter_SkContourMeasureIter(this: *mut SkContourMeasureIter);
}
extern "C" {
    #[link_name = "\u{1}_ZN20SkContourMeasureIterC1ERK6SkPathbf"]
    pub fn SkContourMeasureIter_SkContourMeasureIter1(
        this: *mut SkContourMeasureIter,
        path: *const SkPath,
        forceClosed: bool,
        resScale: SkScalar,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN20SkContourMeasureIterD1Ev"]
    pub fn SkContourMeasureIter_SkContourMeasureIter_destructor(this: *mut SkContourMeasureIter);
}
impl SkContourMeasureIter {
    #[inline]
    pub unsafe fn reset(&mut self, path: *const SkPath, forceClosed: bool, resScale: SkScalar) {
        SkContourMeasureIter_reset(self, path, forceClosed, resScale)
    }
    #[inline]
    pub unsafe fn next(&mut self) -> sk_sp<SkContourMeasure> {
        SkContourMeasureIter_next(self)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkContourMeasureIter_SkContourMeasureIter(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(path: *const SkPath, forceClosed: bool, resScale: SkScalar) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkContourMeasureIter_SkContourMeasureIter1(&mut __bindgen_tmp, path, forceClosed, resScale);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        SkContourMeasureIter_SkContourMeasureIter_destructor(self)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkCubicMap {
    pub fCoeff: [SkPoint; 3usize],
    pub fType: SkCubicMap_Type,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkCubicMap_Type {
    kLine_Type = 0,
    kCubeRoot_Type = 1,
    kSolver_Type = 2,
}
#[test]
fn bindgen_test_layout_SkCubicMap() {
    assert_eq!(
        ::core::mem::size_of::<SkCubicMap>(),
        28usize,
        concat!("Size of: ", stringify!(SkCubicMap))
    );
    assert_eq!(
        ::core::mem::align_of::<SkCubicMap>(),
        4usize,
        concat!("Alignment of ", stringify!(SkCubicMap))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCubicMap>())).fCoeff as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCubicMap),
            "::",
            stringify!(fCoeff)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCubicMap>())).fType as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCubicMap),
            "::",
            stringify!(fType)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkCubicMap13computeYFromXEf"]
    pub fn SkCubicMap_computeYFromX(this: *const SkCubicMap, x: f32) -> f32;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkCubicMap12computeFromTEf"]
    pub fn SkCubicMap_computeFromT(this: *const SkCubicMap, t: f32) -> SkPoint;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkCubicMapC1E7SkPointS0_"]
    pub fn SkCubicMap_SkCubicMap(this: *mut SkCubicMap, p1: SkPoint, p2: SkPoint);
}
impl SkCubicMap {
    #[inline]
    pub unsafe fn computeYFromX(&self, x: f32) -> f32 {
        SkCubicMap_computeYFromX(self, x)
    }
    #[inline]
    pub unsafe fn computeFromT(&self, t: f32) -> SkPoint {
        SkCubicMap_computeFromT(self, t)
    }
    #[inline]
    pub unsafe fn new(p1: SkPoint, p2: SkPoint) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkCubicMap_SkCubicMap(&mut __bindgen_tmp, p1, p2);
        __bindgen_tmp
    }
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub struct SkDataTable {
    pub _bindgen_opaque_blob: [u64; 6usize],
}
pub type SkDataTable_FreeProc =
    ::core::option::Option<unsafe extern "C" fn(context: *mut ::std::os::raw::c_void)>;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkDataTable_Dir {
    pub fPtr: *const ::std::os::raw::c_void,
    pub fSize: usize,
}
#[test]
fn bindgen_test_layout_SkDataTable_Dir() {
    assert_eq!(
        ::core::mem::size_of::<SkDataTable_Dir>(),
        16usize,
        concat!("Size of: ", stringify!(SkDataTable_Dir))
    );
    assert_eq!(
        ::core::mem::align_of::<SkDataTable_Dir>(),
        8usize,
        concat!("Alignment of ", stringify!(SkDataTable_Dir))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkDataTable_Dir>())).fPtr as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkDataTable_Dir),
            "::",
            stringify!(fPtr)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkDataTable_Dir>())).fSize as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkDataTable_Dir),
            "::",
            stringify!(fSize)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union SkDataTable__bindgen_ty_1 {
    pub fDir: *const SkDataTable_Dir,
    pub fElems: *const ::std::os::raw::c_char,
    _bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_SkDataTable__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<SkDataTable__bindgen_ty_1>(),
        8usize,
        concat!("Size of: ", stringify!(SkDataTable__bindgen_ty_1))
    );
    assert_eq!(
        ::core::mem::align_of::<SkDataTable__bindgen_ty_1>(),
        8usize,
        concat!("Alignment of ", stringify!(SkDataTable__bindgen_ty_1))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkDataTable__bindgen_ty_1>())).fDir as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkDataTable__bindgen_ty_1),
            "::",
            stringify!(fDir)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkDataTable__bindgen_ty_1>())).fElems as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkDataTable__bindgen_ty_1),
            "::",
            stringify!(fElems)
        )
    );
}
pub type SkDataTable_INHERITED = SkRefCnt;
#[test]
fn bindgen_test_layout_SkDataTable() {
    assert_eq!(
        ::core::mem::size_of::<SkDataTable>(),
        48usize,
        concat!("Size of: ", stringify!(SkDataTable))
    );
    assert_eq!(
        ::core::mem::align_of::<SkDataTable>(),
        8usize,
        concat!("Alignment of ", stringify!(SkDataTable))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK11SkDataTable6atSizeEi"]
    pub fn SkDataTable_atSize(this: *const SkDataTable, index: ::std::os::raw::c_int) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZNK11SkDataTable2atEiPm"]
    pub fn SkDataTable_at(
        this: *const SkDataTable,
        index: ::std::os::raw::c_int,
        size: *mut usize,
    ) -> *const ::std::os::raw::c_void;
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkDataTable9MakeEmptyEv"]
    pub fn SkDataTable_MakeEmpty() -> sk_sp<SkDataTable>;
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkDataTable14MakeCopyArraysEPKPKvPKmi"]
    pub fn SkDataTable_MakeCopyArrays(
        ptrs: *const *const ::std::os::raw::c_void,
        sizes: *const usize,
        count: ::std::os::raw::c_int,
    ) -> sk_sp<SkDataTable>;
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkDataTable13MakeCopyArrayEPKvmi"]
    pub fn SkDataTable_MakeCopyArray(
        array: *const ::std::os::raw::c_void,
        elemSize: usize,
        count: ::std::os::raw::c_int,
    ) -> sk_sp<SkDataTable>;
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkDataTable13MakeArrayProcEPKvmiPFvPvES2_"]
    pub fn SkDataTable_MakeArrayProc(
        array: *const ::std::os::raw::c_void,
        elemSize: usize,
        count: ::std::os::raw::c_int,
        proc_: SkDataTable_FreeProc,
        context: *mut ::std::os::raw::c_void,
    ) -> sk_sp<SkDataTable>;
}
impl SkDataTable {
    #[inline]
    pub unsafe fn atSize(&self, index: ::std::os::raw::c_int) -> usize {
        SkDataTable_atSize(self, index)
    }
    #[inline]
    pub unsafe fn at(
        &self,
        index: ::std::os::raw::c_int,
        size: *mut usize,
    ) -> *const ::std::os::raw::c_void {
        SkDataTable_at(self, index, size)
    }
    #[inline]
    pub unsafe fn MakeEmpty() -> sk_sp<SkDataTable> {
        SkDataTable_MakeEmpty()
    }
    #[inline]
    pub unsafe fn MakeCopyArrays(
        ptrs: *const *const ::std::os::raw::c_void,
        sizes: *const usize,
        count: ::std::os::raw::c_int,
    ) -> sk_sp<SkDataTable> {
        SkDataTable_MakeCopyArrays(ptrs, sizes, count)
    }
    #[inline]
    pub unsafe fn MakeCopyArray(
        array: *const ::std::os::raw::c_void,
        elemSize: usize,
        count: ::std::os::raw::c_int,
    ) -> sk_sp<SkDataTable> {
        SkDataTable_MakeCopyArray(array, elemSize, count)
    }
    #[inline]
    pub unsafe fn MakeArrayProc(
        array: *const ::std::os::raw::c_void,
        elemSize: usize,
        count: ::std::os::raw::c_int,
        proc_: SkDataTable_FreeProc,
        context: *mut ::std::os::raw::c_void,
    ) -> sk_sp<SkDataTable> {
        SkDataTable_MakeArrayProc(array, elemSize, count, proc_, context)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrBackendSemaphore {
    _unused: [u8; 0],
}
impl GrBackendApi {
    pub const kOpenGL_GrBackend: GrBackendApi = GrBackendApi::kOpenGL;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum GrBackendApi {
    kMetal = 0,
    kDawn = 1,
    kOpenGL = 2,
    kVulkan = 3,
    kMock = 4,
}
#[repr(u8)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum GrMipMapped {
    kNo = 0,
    kYes = 1,
}
#[repr(u8)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum GrRenderable {
    kNo = 0,
    kYes = 1,
}
#[repr(u8)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum GrProtected {
    kNo = 0,
    kYes = 1,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum GrSurfaceOrigin {
    kTopLeft_GrSurfaceOrigin = 0,
    kBottomLeft_GrSurfaceOrigin = 1,
}
pub const GrGLBackendState_kRenderTarget_GrGLBackendState: GrGLBackendState = 1;
pub const GrGLBackendState_kTextureBinding_GrGLBackendState: GrGLBackendState = 2;
pub const GrGLBackendState_kView_GrGLBackendState: GrGLBackendState = 4;
pub const GrGLBackendState_kBlend_GrGLBackendState: GrGLBackendState = 8;
pub const GrGLBackendState_kMSAAEnable_GrGLBackendState: GrGLBackendState = 16;
pub const GrGLBackendState_kVertex_GrGLBackendState: GrGLBackendState = 32;
pub const GrGLBackendState_kStencil_GrGLBackendState: GrGLBackendState = 64;
pub const GrGLBackendState_kPixelStore_GrGLBackendState: GrGLBackendState = 128;
pub const GrGLBackendState_kProgram_GrGLBackendState: GrGLBackendState = 256;
pub const GrGLBackendState_kFixedFunction_GrGLBackendState: GrGLBackendState = 512;
pub const GrGLBackendState_kMisc_GrGLBackendState: GrGLBackendState = 1024;
pub const GrGLBackendState_kPathRendering_GrGLBackendState: GrGLBackendState = 2048;
pub const GrGLBackendState_kALL_GrGLBackendState: GrGLBackendState = 65535;
pub type GrGLBackendState = u32;
pub const kAll_GrBackendState: u32 = 4294967295;
pub const GrFlushFlags_kNone_GrFlushFlags: GrFlushFlags = 0;
pub const GrFlushFlags_kSyncCpu_GrFlushFlag: GrFlushFlags = 1;
pub type GrFlushFlags = u32;
pub type GrGpuFinishedContext = *mut ::std::os::raw::c_void;
pub type GrGpuFinishedProc =
    ::core::option::Option<unsafe extern "C" fn(finishedContext: GrGpuFinishedContext)>;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrFlushInfo {
    pub fFlags: GrFlushFlags,
    pub fNumSemaphores: ::std::os::raw::c_int,
    pub fSignalSemaphores: *mut GrBackendSemaphore,
    pub fFinishedProc: GrGpuFinishedProc,
    pub fFinishedContext: GrGpuFinishedContext,
}
#[test]
fn bindgen_test_layout_GrFlushInfo() {
    assert_eq!(
        ::core::mem::size_of::<GrFlushInfo>(),
        32usize,
        concat!("Size of: ", stringify!(GrFlushInfo))
    );
    assert_eq!(
        ::core::mem::align_of::<GrFlushInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(GrFlushInfo))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrFlushInfo>())).fFlags as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrFlushInfo),
            "::",
            stringify!(fFlags)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrFlushInfo>())).fNumSemaphores as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(GrFlushInfo),
            "::",
            stringify!(fNumSemaphores)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrFlushInfo>())).fSignalSemaphores as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(GrFlushInfo),
            "::",
            stringify!(fSignalSemaphores)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrFlushInfo>())).fFinishedProc as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(GrFlushInfo),
            "::",
            stringify!(fFinishedProc)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrFlushInfo>())).fFinishedContext as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(GrFlushInfo),
            "::",
            stringify!(fFinishedContext)
        )
    );
}
#[repr(u8)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum GrSemaphoresSubmitted {
    kNo = 0,
    kYes = 1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrPrepareForExternalIORequests {
    pub fNumImages: ::std::os::raw::c_int,
    pub fImages: *mut *mut SkImage,
    pub fNumSurfaces: ::std::os::raw::c_int,
    pub fSurfaces: *mut *mut SkSurface,
    pub fPrepareSurfaceForPresent: *mut bool,
}
#[test]
fn bindgen_test_layout_GrPrepareForExternalIORequests() {
    assert_eq!(
        ::core::mem::size_of::<GrPrepareForExternalIORequests>(),
        40usize,
        concat!("Size of: ", stringify!(GrPrepareForExternalIORequests))
    );
    assert_eq!(
        ::core::mem::align_of::<GrPrepareForExternalIORequests>(),
        8usize,
        concat!("Alignment of ", stringify!(GrPrepareForExternalIORequests))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrPrepareForExternalIORequests>())).fNumImages as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrPrepareForExternalIORequests),
            "::",
            stringify!(fNumImages)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrPrepareForExternalIORequests>())).fImages as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(GrPrepareForExternalIORequests),
            "::",
            stringify!(fImages)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrPrepareForExternalIORequests>())).fNumSurfaces as *const _
                as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(GrPrepareForExternalIORequests),
            "::",
            stringify!(fNumSurfaces)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrPrepareForExternalIORequests>())).fSurfaces as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(GrPrepareForExternalIORequests),
            "::",
            stringify!(fSurfaces)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrPrepareForExternalIORequests>())).fPrepareSurfaceForPresent
                as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(GrPrepareForExternalIORequests),
            "::",
            stringify!(fPrepareSurfaceForPresent)
        )
    );
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum GrGLStandard {
    kNone_GrGLStandard = 0,
    kGL_GrGLStandard = 1,
    kGLES_GrGLStandard = 2,
    kWebGL_GrGLStandard = 3,
}
pub type GrGLenum = ::std::os::raw::c_uint;
pub type GrGLint = ::std::os::raw::c_int;
pub type GrGLuint = ::std::os::raw::c_uint;
pub type GrGLfloat = f32;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrGLTextureInfo {
    pub fTarget: GrGLenum,
    pub fID: GrGLuint,
    pub fFormat: GrGLenum,
}
#[test]
fn bindgen_test_layout_GrGLTextureInfo() {
    assert_eq!(
        ::core::mem::size_of::<GrGLTextureInfo>(),
        12usize,
        concat!("Size of: ", stringify!(GrGLTextureInfo))
    );
    assert_eq!(
        ::core::mem::align_of::<GrGLTextureInfo>(),
        4usize,
        concat!("Alignment of ", stringify!(GrGLTextureInfo))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrGLTextureInfo>())).fTarget as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLTextureInfo),
            "::",
            stringify!(fTarget)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrGLTextureInfo>())).fID as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLTextureInfo),
            "::",
            stringify!(fID)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrGLTextureInfo>())).fFormat as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLTextureInfo),
            "::",
            stringify!(fFormat)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrGLFramebufferInfo {
    pub fFBOID: GrGLuint,
    pub fFormat: GrGLenum,
}
#[test]
fn bindgen_test_layout_GrGLFramebufferInfo() {
    assert_eq!(
        ::core::mem::size_of::<GrGLFramebufferInfo>(),
        8usize,
        concat!("Size of: ", stringify!(GrGLFramebufferInfo))
    );
    assert_eq!(
        ::core::mem::align_of::<GrGLFramebufferInfo>(),
        4usize,
        concat!("Alignment of ", stringify!(GrGLFramebufferInfo))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrGLFramebufferInfo>())).fFBOID as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLFramebufferInfo),
            "::",
            stringify!(fFBOID)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrGLFramebufferInfo>())).fFormat as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLFramebufferInfo),
            "::",
            stringify!(fFormat)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkMask {
    _unused: [u8; 0],
}
#[repr(C)]
pub struct SkPixmap {
    pub fPixels: *const ::std::os::raw::c_void,
    pub fRowBytes: usize,
    pub fInfo: SkImageInfo,
}
#[test]
fn bindgen_test_layout_SkPixmap() {
    assert_eq!(
        ::core::mem::size_of::<SkPixmap>(),
        40usize,
        concat!("Size of: ", stringify!(SkPixmap))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPixmap>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPixmap))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPixmap>())).fPixels as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPixmap),
            "::",
            stringify!(fPixels)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPixmap>())).fRowBytes as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPixmap),
            "::",
            stringify!(fRowBytes)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPixmap>())).fInfo as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPixmap),
            "::",
            stringify!(fInfo)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkPixmap5resetEv"]
    pub fn SkPixmap_reset(this: *mut SkPixmap);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkPixmap5resetERK11SkImageInfoPKvm"]
    pub fn SkPixmap_reset1(
        this: *mut SkPixmap,
        info: *const SkImageInfo,
        addr: *const ::std::os::raw::c_void,
        rowBytes: usize,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkPixmap13setColorSpaceE5sk_spI12SkColorSpaceE"]
    pub fn SkPixmap_setColorSpace(this: *mut SkPixmap, colorSpace: sk_sp<SkColorSpace>);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkPixmap5resetERK6SkMask"]
    pub fn SkPixmap_reset2(this: *mut SkPixmap, mask: *const SkMask) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkPixmap13extractSubsetEPS_RK7SkIRect"]
    pub fn SkPixmap_extractSubset(
        this: *const SkPixmap,
        subset: *mut SkPixmap,
        area: *const SkIRect,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkPixmap15computeIsOpaqueEv"]
    pub fn SkPixmap_computeIsOpaque(this: *const SkPixmap) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkPixmap8getColorEii"]
    pub fn SkPixmap_getColor(
        this: *const SkPixmap,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
    ) -> SkColor;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkPixmap9getAlphafEii"]
    pub fn SkPixmap_getAlphaf(
        this: *const SkPixmap,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
    ) -> f32;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkPixmap10readPixelsERK11SkImageInfoPvmii"]
    pub fn SkPixmap_readPixels(
        this: *const SkPixmap,
        dstInfo: *const SkImageInfo,
        dstPixels: *mut ::std::os::raw::c_void,
        dstRowBytes: usize,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkPixmap11scalePixelsERKS_15SkFilterQuality"]
    pub fn SkPixmap_scalePixels(
        this: *const SkPixmap,
        dst: *const SkPixmap,
        filterQuality: SkFilterQuality,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkPixmap5eraseEjRK7SkIRect"]
    pub fn SkPixmap_erase(this: *const SkPixmap, color: SkColor, subset: *const SkIRect) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkPixmap5eraseERK8SkRGBA4fIL11SkAlphaType3EEPK7SkIRect"]
    pub fn SkPixmap_erase1(
        this: *const SkPixmap,
        color: *const SkColor4f,
        subset: *const SkIRect,
    ) -> bool;
}
impl SkPixmap {
    #[inline]
    pub unsafe fn reset(&mut self) {
        SkPixmap_reset(self)
    }
    #[inline]
    pub unsafe fn reset1(
        &mut self,
        info: *const SkImageInfo,
        addr: *const ::std::os::raw::c_void,
        rowBytes: usize,
    ) {
        SkPixmap_reset1(self, info, addr, rowBytes)
    }
    #[inline]
    pub unsafe fn setColorSpace(&mut self, colorSpace: sk_sp<SkColorSpace>) {
        SkPixmap_setColorSpace(self, colorSpace)
    }
    #[inline]
    pub unsafe fn reset2(&mut self, mask: *const SkMask) -> bool {
        SkPixmap_reset2(self, mask)
    }
    #[inline]
    pub unsafe fn extractSubset(&self, subset: *mut SkPixmap, area: *const SkIRect) -> bool {
        SkPixmap_extractSubset(self, subset, area)
    }
    #[inline]
    pub unsafe fn computeIsOpaque(&self) -> bool {
        SkPixmap_computeIsOpaque(self)
    }
    #[inline]
    pub unsafe fn getColor(&self, x: ::std::os::raw::c_int, y: ::std::os::raw::c_int) -> SkColor {
        SkPixmap_getColor(self, x, y)
    }
    #[inline]
    pub unsafe fn getAlphaf(&self, x: ::std::os::raw::c_int, y: ::std::os::raw::c_int) -> f32 {
        SkPixmap_getAlphaf(self, x, y)
    }
    #[inline]
    pub unsafe fn readPixels(
        &self,
        dstInfo: *const SkImageInfo,
        dstPixels: *mut ::std::os::raw::c_void,
        dstRowBytes: usize,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
    ) -> bool {
        SkPixmap_readPixels(self, dstInfo, dstPixels, dstRowBytes, srcX, srcY)
    }
    #[inline]
    pub unsafe fn scalePixels(&self, dst: *const SkPixmap, filterQuality: SkFilterQuality) -> bool {
        SkPixmap_scalePixels(self, dst, filterQuality)
    }
    #[inline]
    pub unsafe fn erase(&self, color: SkColor, subset: *const SkIRect) -> bool {
        SkPixmap_erase(self, color, subset)
    }
    #[inline]
    pub unsafe fn erase1(&self, color: *const SkColor4f, subset: *const SkIRect) -> bool {
        SkPixmap_erase1(self, color, subset)
    }
}
impl SkTileMode {
    pub const kLastTileMode: SkTileMode = SkTileMode::kDecal;
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkTileMode {
    kClamp = 0,
    kRepeat = 1,
    kMirror = 2,
    kDecal = 3,
}
#[repr(C)]
pub struct SkBitmap {
    pub fPixelRef: sk_sp<SkPixelRef>,
    pub fPixmap: SkPixmap,
    pub fFlags: u8,
}
pub const SkBitmap_AllocFlags_kZeroPixels_AllocFlag: SkBitmap_AllocFlags = 1;
pub type SkBitmap_AllocFlags = u32;
#[repr(C)]
pub struct SkBitmap_Allocator {
    pub _base: SkRefCnt,
}
pub type SkBitmap_Allocator_INHERITED = SkRefCnt;
#[test]
fn bindgen_test_layout_SkBitmap_Allocator() {
    assert_eq!(
        ::core::mem::size_of::<SkBitmap_Allocator>(),
        16usize,
        concat!("Size of: ", stringify!(SkBitmap_Allocator))
    );
    assert_eq!(
        ::core::mem::align_of::<SkBitmap_Allocator>(),
        8usize,
        concat!("Alignment of ", stringify!(SkBitmap_Allocator))
    );
}
#[repr(C)]
pub struct SkBitmap_HeapAllocator {
    pub _base: SkBitmap_Allocator,
}
#[test]
fn bindgen_test_layout_SkBitmap_HeapAllocator() {
    assert_eq!(
        ::core::mem::size_of::<SkBitmap_HeapAllocator>(),
        16usize,
        concat!("Size of: ", stringify!(SkBitmap_HeapAllocator))
    );
    assert_eq!(
        ::core::mem::align_of::<SkBitmap_HeapAllocator>(),
        8usize,
        concat!("Alignment of ", stringify!(SkBitmap_HeapAllocator))
    );
}
pub const SkBitmap_Flags_kImageIsVolatile_Flag: SkBitmap_Flags = 2;
pub type SkBitmap_Flags = u32;
#[test]
fn bindgen_test_layout_SkBitmap() {
    assert_eq!(
        ::core::mem::size_of::<SkBitmap>(),
        56usize,
        concat!("Size of: ", stringify!(SkBitmap))
    );
    assert_eq!(
        ::core::mem::align_of::<SkBitmap>(),
        8usize,
        concat!("Alignment of ", stringify!(SkBitmap))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkBitmap>())).fPixelRef as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkBitmap),
            "::",
            stringify!(fPixelRef)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkBitmap>())).fPixmap as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkBitmap),
            "::",
            stringify!(fPixmap)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkBitmap>())).fFlags as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(SkBitmap),
            "::",
            stringify!(fFlags)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap4swapERS_"]
    pub fn SkBitmap_swap(this: *mut SkBitmap, other: *mut SkBitmap);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap12setAlphaTypeE11SkAlphaType"]
    pub fn SkBitmap_setAlphaType(this: *mut SkBitmap, alphaType: SkAlphaType) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkBitmap11isImmutableEv"]
    pub fn SkBitmap_isImmutable(this: *const SkBitmap) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap12setImmutableEv"]
    pub fn SkBitmap_setImmutable(this: *mut SkBitmap);
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkBitmap10isVolatileEv"]
    pub fn SkBitmap_isVolatile(this: *const SkBitmap) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap13setIsVolatileEb"]
    pub fn SkBitmap_setIsVolatile(this: *mut SkBitmap, isVolatile: bool);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap5resetEv"]
    pub fn SkBitmap_reset(this: *mut SkBitmap);
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkBitmap9getBoundsEP6SkRect"]
    pub fn SkBitmap_getBounds(this: *const SkBitmap, bounds: *mut SkRect);
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkBitmap9getBoundsEP7SkIRect"]
    pub fn SkBitmap_getBounds1(this: *const SkBitmap, bounds: *mut SkIRect);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap7setInfoERK11SkImageInfom"]
    pub fn SkBitmap_setInfo(
        this: *mut SkBitmap,
        imageInfo: *const SkImageInfo,
        rowBytes: usize,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap19tryAllocPixelsFlagsERK11SkImageInfoj"]
    pub fn SkBitmap_tryAllocPixelsFlags(
        this: *mut SkBitmap,
        info: *const SkImageInfo,
        flags: u32,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap16allocPixelsFlagsERK11SkImageInfoj"]
    pub fn SkBitmap_allocPixelsFlags(this: *mut SkBitmap, info: *const SkImageInfo, flags: u32);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap14tryAllocPixelsERK11SkImageInfom"]
    pub fn SkBitmap_tryAllocPixels(
        this: *mut SkBitmap,
        info: *const SkImageInfo,
        rowBytes: usize,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap11allocPixelsERK11SkImageInfom"]
    pub fn SkBitmap_allocPixels(this: *mut SkBitmap, info: *const SkImageInfo, rowBytes: usize);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap11allocPixelsERK11SkImageInfo"]
    pub fn SkBitmap_allocPixels1(this: *mut SkBitmap, info: *const SkImageInfo);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap17tryAllocN32PixelsEiib"]
    pub fn SkBitmap_tryAllocN32Pixels(
        this: *mut SkBitmap,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        isOpaque: bool,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap14allocN32PixelsEiib"]
    pub fn SkBitmap_allocN32Pixels(
        this: *mut SkBitmap,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        isOpaque: bool,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap13installPixelsERK11SkImageInfoPvmPFvS3_S3_ES3_"]
    pub fn SkBitmap_installPixels(
        this: *mut SkBitmap,
        info: *const SkImageInfo,
        pixels: *mut ::std::os::raw::c_void,
        rowBytes: usize,
        releaseProc: ::core::option::Option<
            unsafe extern "C" fn(
                addr: *mut ::std::os::raw::c_void,
                context: *mut ::std::os::raw::c_void,
            ),
        >,
        context: *mut ::std::os::raw::c_void,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap13installPixelsERK8SkPixmap"]
    pub fn SkBitmap_installPixels1(this: *mut SkBitmap, pixmap: *const SkPixmap) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap17installMaskPixelsERK6SkMask"]
    pub fn SkBitmap_installMaskPixels(this: *mut SkBitmap, mask: *const SkMask) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap9setPixelsEPv"]
    pub fn SkBitmap_setPixels(this: *mut SkBitmap, pixels: *mut ::std::os::raw::c_void);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap11allocPixelsEv"]
    pub fn SkBitmap_allocPixels2(this: *mut SkBitmap);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap14tryAllocPixelsEPNS_9AllocatorE"]
    pub fn SkBitmap_tryAllocPixels1(
        this: *mut SkBitmap,
        allocator: *mut SkBitmap_Allocator,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap11allocPixelsEPNS_9AllocatorE"]
    pub fn SkBitmap_allocPixels3(this: *mut SkBitmap, allocator: *mut SkBitmap_Allocator);
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkBitmap14pixelRefOriginEv"]
    pub fn SkBitmap_pixelRefOrigin(this: *const SkBitmap) -> SkIPoint;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap11setPixelRefE5sk_spI10SkPixelRefEii"]
    pub fn SkBitmap_setPixelRef(
        this: *mut SkBitmap,
        pixelRef: sk_sp<SkPixelRef>,
        dx: ::std::os::raw::c_int,
        dy: ::std::os::raw::c_int,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkBitmap15getGenerationIDEv"]
    pub fn SkBitmap_getGenerationID(this: *const SkBitmap) -> u32;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkBitmap19notifyPixelsChangedEv"]
    pub fn SkBitmap_notifyPixelsChanged(this: *const SkBitmap);
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkBitmap10eraseColorEj"]
    pub fn SkBitmap_eraseColor(this: *const SkBitmap, c: SkColor);
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkBitmap5eraseEjRK7SkIRect"]
    pub fn SkBitmap_erase(this: *const SkBitmap, c: SkColor, area: *const SkIRect);
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkBitmap7getAddrEii"]
    pub fn SkBitmap_getAddr(
        this: *const SkBitmap,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkBitmap13extractSubsetEPS_RK7SkIRect"]
    pub fn SkBitmap_extractSubset(
        this: *const SkBitmap,
        dst: *mut SkBitmap,
        subset: *const SkIRect,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkBitmap10readPixelsERK11SkImageInfoPvmii"]
    pub fn SkBitmap_readPixels(
        this: *const SkBitmap,
        dstInfo: *const SkImageInfo,
        dstPixels: *mut ::std::os::raw::c_void,
        dstRowBytes: usize,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkBitmap10readPixelsERK8SkPixmapii"]
    pub fn SkBitmap_readPixels1(
        this: *const SkBitmap,
        dst: *const SkPixmap,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap11writePixelsERK8SkPixmapii"]
    pub fn SkBitmap_writePixels(
        this: *mut SkBitmap,
        src: *const SkPixmap,
        dstX: ::std::os::raw::c_int,
        dstY: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkBitmap12extractAlphaEPS_PK7SkPaintPNS_9AllocatorEP8SkIPoint"]
    pub fn SkBitmap_extractAlpha(
        this: *const SkBitmap,
        dst: *mut SkBitmap,
        paint: *const SkPaint,
        allocator: *mut SkBitmap_Allocator,
        offset: *mut SkIPoint,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkBitmap10peekPixelsEP8SkPixmap"]
    pub fn SkBitmap_peekPixels(this: *const SkBitmap, pixmap: *mut SkPixmap) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkBitmap10makeShaderE10SkTileModeS0_PK8SkMatrix"]
    pub fn SkBitmap_makeShader(
        this: *const SkBitmap,
        tmx: SkTileMode,
        tmy: SkTileMode,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkBitmap10makeShaderEPK8SkMatrix"]
    pub fn SkBitmap_makeShader1(
        this: *const SkBitmap,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader>;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmapC1Ev"]
    pub fn SkBitmap_SkBitmap(this: *mut SkBitmap);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmapC1ERKS_"]
    pub fn SkBitmap_SkBitmap1(this: *mut SkBitmap, src: *const SkBitmap);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmapC1EOS_"]
    pub fn SkBitmap_SkBitmap2(this: *mut SkBitmap, src: *mut SkBitmap);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmapD1Ev"]
    pub fn SkBitmap_SkBitmap_destructor(this: *mut SkBitmap);
}
impl SkBitmap {
    #[inline]
    pub unsafe fn swap(&mut self, other: *mut SkBitmap) {
        SkBitmap_swap(self, other)
    }
    #[inline]
    pub unsafe fn setAlphaType(&mut self, alphaType: SkAlphaType) -> bool {
        SkBitmap_setAlphaType(self, alphaType)
    }
    #[inline]
    pub unsafe fn isImmutable(&self) -> bool {
        SkBitmap_isImmutable(self)
    }
    #[inline]
    pub unsafe fn setImmutable(&mut self) {
        SkBitmap_setImmutable(self)
    }
    #[inline]
    pub unsafe fn isVolatile(&self) -> bool {
        SkBitmap_isVolatile(self)
    }
    #[inline]
    pub unsafe fn setIsVolatile(&mut self, isVolatile: bool) {
        SkBitmap_setIsVolatile(self, isVolatile)
    }
    #[inline]
    pub unsafe fn reset(&mut self) {
        SkBitmap_reset(self)
    }
    #[inline]
    pub unsafe fn getBounds(&self, bounds: *mut SkRect) {
        SkBitmap_getBounds(self, bounds)
    }
    #[inline]
    pub unsafe fn getBounds1(&self, bounds: *mut SkIRect) {
        SkBitmap_getBounds1(self, bounds)
    }
    #[inline]
    pub unsafe fn setInfo(&mut self, imageInfo: *const SkImageInfo, rowBytes: usize) -> bool {
        SkBitmap_setInfo(self, imageInfo, rowBytes)
    }
    #[inline]
    pub unsafe fn tryAllocPixelsFlags(&mut self, info: *const SkImageInfo, flags: u32) -> bool {
        SkBitmap_tryAllocPixelsFlags(self, info, flags)
    }
    #[inline]
    pub unsafe fn allocPixelsFlags(&mut self, info: *const SkImageInfo, flags: u32) {
        SkBitmap_allocPixelsFlags(self, info, flags)
    }
    #[inline]
    pub unsafe fn tryAllocPixels(&mut self, info: *const SkImageInfo, rowBytes: usize) -> bool {
        SkBitmap_tryAllocPixels(self, info, rowBytes)
    }
    #[inline]
    pub unsafe fn allocPixels(&mut self, info: *const SkImageInfo, rowBytes: usize) {
        SkBitmap_allocPixels(self, info, rowBytes)
    }
    #[inline]
    pub unsafe fn allocPixels1(&mut self, info: *const SkImageInfo) {
        SkBitmap_allocPixels1(self, info)
    }
    #[inline]
    pub unsafe fn tryAllocN32Pixels(
        &mut self,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        isOpaque: bool,
    ) -> bool {
        SkBitmap_tryAllocN32Pixels(self, width, height, isOpaque)
    }
    #[inline]
    pub unsafe fn allocN32Pixels(
        &mut self,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        isOpaque: bool,
    ) {
        SkBitmap_allocN32Pixels(self, width, height, isOpaque)
    }
    #[inline]
    pub unsafe fn installPixels(
        &mut self,
        info: *const SkImageInfo,
        pixels: *mut ::std::os::raw::c_void,
        rowBytes: usize,
        releaseProc: ::core::option::Option<
            unsafe extern "C" fn(
                addr: *mut ::std::os::raw::c_void,
                context: *mut ::std::os::raw::c_void,
            ),
        >,
        context: *mut ::std::os::raw::c_void,
    ) -> bool {
        SkBitmap_installPixels(self, info, pixels, rowBytes, releaseProc, context)
    }
    #[inline]
    pub unsafe fn installPixels1(&mut self, pixmap: *const SkPixmap) -> bool {
        SkBitmap_installPixels1(self, pixmap)
    }
    #[inline]
    pub unsafe fn installMaskPixels(&mut self, mask: *const SkMask) -> bool {
        SkBitmap_installMaskPixels(self, mask)
    }
    #[inline]
    pub unsafe fn setPixels(&mut self, pixels: *mut ::std::os::raw::c_void) {
        SkBitmap_setPixels(self, pixels)
    }
    #[inline]
    pub unsafe fn allocPixels2(&mut self) {
        SkBitmap_allocPixels2(self)
    }
    #[inline]
    pub unsafe fn tryAllocPixels1(&mut self, allocator: *mut SkBitmap_Allocator) -> bool {
        SkBitmap_tryAllocPixels1(self, allocator)
    }
    #[inline]
    pub unsafe fn allocPixels3(&mut self, allocator: *mut SkBitmap_Allocator) {
        SkBitmap_allocPixels3(self, allocator)
    }
    #[inline]
    pub unsafe fn pixelRefOrigin(&self) -> SkIPoint {
        SkBitmap_pixelRefOrigin(self)
    }
    #[inline]
    pub unsafe fn setPixelRef(
        &mut self,
        pixelRef: sk_sp<SkPixelRef>,
        dx: ::std::os::raw::c_int,
        dy: ::std::os::raw::c_int,
    ) {
        SkBitmap_setPixelRef(self, pixelRef, dx, dy)
    }
    #[inline]
    pub unsafe fn getGenerationID(&self) -> u32 {
        SkBitmap_getGenerationID(self)
    }
    #[inline]
    pub unsafe fn notifyPixelsChanged(&self) {
        SkBitmap_notifyPixelsChanged(self)
    }
    #[inline]
    pub unsafe fn eraseColor(&self, c: SkColor) {
        SkBitmap_eraseColor(self, c)
    }
    #[inline]
    pub unsafe fn erase(&self, c: SkColor, area: *const SkIRect) {
        SkBitmap_erase(self, c, area)
    }
    #[inline]
    pub unsafe fn getAddr(
        &self,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_void {
        SkBitmap_getAddr(self, x, y)
    }
    #[inline]
    pub unsafe fn extractSubset(&self, dst: *mut SkBitmap, subset: *const SkIRect) -> bool {
        SkBitmap_extractSubset(self, dst, subset)
    }
    #[inline]
    pub unsafe fn readPixels(
        &self,
        dstInfo: *const SkImageInfo,
        dstPixels: *mut ::std::os::raw::c_void,
        dstRowBytes: usize,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
    ) -> bool {
        SkBitmap_readPixels(self, dstInfo, dstPixels, dstRowBytes, srcX, srcY)
    }
    #[inline]
    pub unsafe fn readPixels1(
        &self,
        dst: *const SkPixmap,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
    ) -> bool {
        SkBitmap_readPixels1(self, dst, srcX, srcY)
    }
    #[inline]
    pub unsafe fn writePixels(
        &mut self,
        src: *const SkPixmap,
        dstX: ::std::os::raw::c_int,
        dstY: ::std::os::raw::c_int,
    ) -> bool {
        SkBitmap_writePixels(self, src, dstX, dstY)
    }
    #[inline]
    pub unsafe fn extractAlpha(
        &self,
        dst: *mut SkBitmap,
        paint: *const SkPaint,
        allocator: *mut SkBitmap_Allocator,
        offset: *mut SkIPoint,
    ) -> bool {
        SkBitmap_extractAlpha(self, dst, paint, allocator, offset)
    }
    #[inline]
    pub unsafe fn peekPixels(&self, pixmap: *mut SkPixmap) -> bool {
        SkBitmap_peekPixels(self, pixmap)
    }
    #[inline]
    pub unsafe fn makeShader(
        &self,
        tmx: SkTileMode,
        tmy: SkTileMode,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader> {
        SkBitmap_makeShader(self, tmx, tmy, localMatrix)
    }
    #[inline]
    pub unsafe fn makeShader1(&self, localMatrix: *const SkMatrix) -> sk_sp<SkShader> {
        SkBitmap_makeShader1(self, localMatrix)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkBitmap_SkBitmap(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(src: *const SkBitmap) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkBitmap_SkBitmap1(&mut __bindgen_tmp, src);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new2(src: *mut SkBitmap) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkBitmap_SkBitmap2(&mut __bindgen_tmp, src);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        SkBitmap_SkBitmap_destructor(self)
    }
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkBitmap13HeapAllocator13allocPixelRefEPS_"]
    pub fn SkBitmap_HeapAllocator_allocPixelRef(
        this: *mut ::std::os::raw::c_void,
        bitmap: *mut SkBitmap,
    ) -> bool;
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkEncodedImageFormat {
    kBMP = 0,
    kGIF = 1,
    kICO = 2,
    kJPEG = 3,
    kPNG = 4,
    kWBMP = 5,
    kWEBP = 6,
    kPKM = 7,
    kKTX = 8,
    kASTC = 9,
    kDNG = 10,
    kHEIF = 11,
}
#[repr(C)]
pub struct SkStream__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
pub struct SkStream {
    pub vtable_: *const SkStream__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_SkStream() {
    assert_eq!(
        ::core::mem::size_of::<SkStream>(),
        8usize,
        concat!("Size of: ", stringify!(SkStream))
    );
    assert_eq!(
        ::core::mem::align_of::<SkStream>(),
        8usize,
        concat!("Alignment of ", stringify!(SkStream))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkStream12MakeFromFileEPKc"]
    pub fn SkStream_MakeFromFile(path: *const ::std::os::raw::c_char) -> u64;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkStream6readS8EPa"]
    pub fn SkStream_readS8(this: *mut SkStream, arg1: *mut i8) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkStream7readS16EPs"]
    pub fn SkStream_readS16(this: *mut SkStream, arg1: *mut i16) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkStream7readS32EPi"]
    pub fn SkStream_readS32(this: *mut SkStream, arg1: *mut i32) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkStream10readScalarEPf"]
    pub fn SkStream_readScalar(this: *mut SkStream, arg1: *mut SkScalar) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkStream14readPackedUIntEPm"]
    pub fn SkStream_readPackedUInt(this: *mut SkStream, arg1: *mut usize) -> bool;
}
impl SkStream {
    #[inline]
    pub unsafe fn MakeFromFile(path: *const ::std::os::raw::c_char) -> u64 {
        SkStream_MakeFromFile(path)
    }
    #[inline]
    pub unsafe fn readS8(&mut self, arg1: *mut i8) -> bool {
        SkStream_readS8(self, arg1)
    }
    #[inline]
    pub unsafe fn readS16(&mut self, arg1: *mut i16) -> bool {
        SkStream_readS16(self, arg1)
    }
    #[inline]
    pub unsafe fn readS32(&mut self, arg1: *mut i32) -> bool {
        SkStream_readS32(self, arg1)
    }
    #[inline]
    pub unsafe fn readScalar(&mut self, arg1: *mut SkScalar) -> bool {
        SkStream_readScalar(self, arg1)
    }
    #[inline]
    pub unsafe fn readPackedUInt(&mut self, arg1: *mut usize) -> bool {
        SkStream_readPackedUInt(self, arg1)
    }
}
#[repr(C)]
pub struct SkStreamRewindable {
    pub _base: SkStream,
}
#[test]
fn bindgen_test_layout_SkStreamRewindable() {
    assert_eq!(
        ::core::mem::size_of::<SkStreamRewindable>(),
        8usize,
        concat!("Size of: ", stringify!(SkStreamRewindable))
    );
    assert_eq!(
        ::core::mem::align_of::<SkStreamRewindable>(),
        8usize,
        concat!("Alignment of ", stringify!(SkStreamRewindable))
    );
}
#[repr(C)]
pub struct SkStreamSeekable {
    pub _base: SkStreamRewindable,
}
#[test]
fn bindgen_test_layout_SkStreamSeekable() {
    assert_eq!(
        ::core::mem::size_of::<SkStreamSeekable>(),
        8usize,
        concat!("Size of: ", stringify!(SkStreamSeekable))
    );
    assert_eq!(
        ::core::mem::align_of::<SkStreamSeekable>(),
        8usize,
        concat!("Alignment of ", stringify!(SkStreamSeekable))
    );
}
#[repr(C)]
pub struct SkStreamAsset {
    pub _base: SkStreamSeekable,
}
#[test]
fn bindgen_test_layout_SkStreamAsset() {
    assert_eq!(
        ::core::mem::size_of::<SkStreamAsset>(),
        8usize,
        concat!("Size of: ", stringify!(SkStreamAsset))
    );
    assert_eq!(
        ::core::mem::align_of::<SkStreamAsset>(),
        8usize,
        concat!("Alignment of ", stringify!(SkStreamAsset))
    );
}
#[repr(C)]
pub struct SkStreamMemory {
    pub _base: SkStreamAsset,
}
#[test]
fn bindgen_test_layout_SkStreamMemory() {
    assert_eq!(
        ::core::mem::size_of::<SkStreamMemory>(),
        8usize,
        concat!("Size of: ", stringify!(SkStreamMemory))
    );
    assert_eq!(
        ::core::mem::align_of::<SkStreamMemory>(),
        8usize,
        concat!("Alignment of ", stringify!(SkStreamMemory))
    );
}
#[repr(C)]
pub struct SkWStream__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
pub struct SkWStream {
    pub vtable_: *const SkWStream__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_SkWStream() {
    assert_eq!(
        ::core::mem::size_of::<SkWStream>(),
        8usize,
        concat!("Size of: ", stringify!(SkWStream))
    );
    assert_eq!(
        ::core::mem::align_of::<SkWStream>(),
        8usize,
        concat!("Alignment of ", stringify!(SkWStream))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkWStream14writeDecAsTextEi"]
    pub fn SkWStream_writeDecAsText(this: *mut SkWStream, arg1: i32) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkWStream17writeBigDecAsTextEli"]
    pub fn SkWStream_writeBigDecAsText(
        this: *mut SkWStream,
        arg1: i64,
        minDigits: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkWStream14writeHexAsTextEji"]
    pub fn SkWStream_writeHexAsText(
        this: *mut SkWStream,
        arg1: u32,
        minDigits: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkWStream17writeScalarAsTextEf"]
    pub fn SkWStream_writeScalarAsText(this: *mut SkWStream, arg1: SkScalar) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkWStream11writeScalarEf"]
    pub fn SkWStream_writeScalar(this: *mut SkWStream, arg1: SkScalar) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkWStream15writePackedUIntEm"]
    pub fn SkWStream_writePackedUInt(this: *mut SkWStream, arg1: usize) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkWStream11writeStreamEP8SkStreamm"]
    pub fn SkWStream_writeStream(this: *mut SkWStream, input: *mut SkStream, length: usize)
        -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkWStream16SizeOfPackedUIntEm"]
    pub fn SkWStream_SizeOfPackedUInt(value: usize) -> ::std::os::raw::c_int;
}
impl SkWStream {
    #[inline]
    pub unsafe fn writeDecAsText(&mut self, arg1: i32) -> bool {
        SkWStream_writeDecAsText(self, arg1)
    }
    #[inline]
    pub unsafe fn writeBigDecAsText(
        &mut self,
        arg1: i64,
        minDigits: ::std::os::raw::c_int,
    ) -> bool {
        SkWStream_writeBigDecAsText(self, arg1, minDigits)
    }
    #[inline]
    pub unsafe fn writeHexAsText(&mut self, arg1: u32, minDigits: ::std::os::raw::c_int) -> bool {
        SkWStream_writeHexAsText(self, arg1, minDigits)
    }
    #[inline]
    pub unsafe fn writeScalarAsText(&mut self, arg1: SkScalar) -> bool {
        SkWStream_writeScalarAsText(self, arg1)
    }
    #[inline]
    pub unsafe fn writeScalar(&mut self, arg1: SkScalar) -> bool {
        SkWStream_writeScalar(self, arg1)
    }
    #[inline]
    pub unsafe fn writePackedUInt(&mut self, arg1: usize) -> bool {
        SkWStream_writePackedUInt(self, arg1)
    }
    #[inline]
    pub unsafe fn writeStream(&mut self, input: *mut SkStream, length: usize) -> bool {
        SkWStream_writeStream(self, input, length)
    }
    #[inline]
    pub unsafe fn SizeOfPackedUInt(value: usize) -> ::std::os::raw::c_int {
        SkWStream_SizeOfPackedUInt(value)
    }
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkWStreamD1Ev"]
    pub fn SkWStream_SkWStream_destructor(this: *mut SkWStream);
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkWStream5flushEv"]
    pub fn SkWStream_flush(this: *mut ::std::os::raw::c_void);
}
#[repr(C)]
pub struct SkMemoryStream {
    pub _base: SkStreamMemory,
    pub fData: sk_sp<SkData>,
    pub fOffset: usize,
}
pub type SkMemoryStream_INHERITED = SkStreamMemory;
#[test]
fn bindgen_test_layout_SkMemoryStream() {
    assert_eq!(
        ::core::mem::size_of::<SkMemoryStream>(),
        24usize,
        concat!("Size of: ", stringify!(SkMemoryStream))
    );
    assert_eq!(
        ::core::mem::align_of::<SkMemoryStream>(),
        8usize,
        concat!("Alignment of ", stringify!(SkMemoryStream))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkMemoryStream>())).fData as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkMemoryStream),
            "::",
            stringify!(fData)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkMemoryStream>())).fOffset as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkMemoryStream),
            "::",
            stringify!(fOffset)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkMemoryStream8MakeCopyEPKvm"]
    pub fn SkMemoryStream_MakeCopy(data: *const ::std::os::raw::c_void, length: usize) -> u64;
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkMemoryStream10MakeDirectEPKvm"]
    pub fn SkMemoryStream_MakeDirect(data: *const ::std::os::raw::c_void, length: usize) -> u64;
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkMemoryStream4MakeE5sk_spI6SkDataE"]
    pub fn SkMemoryStream_Make(data: sk_sp<SkData>) -> u64;
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkMemoryStream14setMemoryOwnedEPKvm"]
    pub fn SkMemoryStream_setMemoryOwned(
        this: *mut SkMemoryStream,
        data: *const ::std::os::raw::c_void,
        length: usize,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkMemoryStream7setDataE5sk_spI6SkDataE"]
    pub fn SkMemoryStream_setData(this: *mut SkMemoryStream, data: sk_sp<SkData>);
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkMemoryStream12skipToAlign4Ev"]
    pub fn SkMemoryStream_skipToAlign4(this: *mut SkMemoryStream);
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkMemoryStream8getAtPosEv"]
    pub fn SkMemoryStream_getAtPos(this: *mut SkMemoryStream) -> *const ::std::os::raw::c_void;
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkMemoryStreamC1Ev"]
    pub fn SkMemoryStream_SkMemoryStream(this: *mut SkMemoryStream);
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkMemoryStreamC1Em"]
    pub fn SkMemoryStream_SkMemoryStream1(this: *mut SkMemoryStream, length: usize);
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkMemoryStreamC1EPKvmb"]
    pub fn SkMemoryStream_SkMemoryStream2(
        this: *mut SkMemoryStream,
        data: *const ::std::os::raw::c_void,
        length: usize,
        copyData: bool,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkMemoryStreamC1E5sk_spI6SkDataE"]
    pub fn SkMemoryStream_SkMemoryStream3(this: *mut SkMemoryStream, data: sk_sp<SkData>);
}
impl SkMemoryStream {
    #[inline]
    pub unsafe fn MakeCopy(data: *const ::std::os::raw::c_void, length: usize) -> u64 {
        SkMemoryStream_MakeCopy(data, length)
    }
    #[inline]
    pub unsafe fn MakeDirect(data: *const ::std::os::raw::c_void, length: usize) -> u64 {
        SkMemoryStream_MakeDirect(data, length)
    }
    #[inline]
    pub unsafe fn Make(data: sk_sp<SkData>) -> u64 {
        SkMemoryStream_Make(data)
    }
    #[inline]
    pub unsafe fn setMemoryOwned(&mut self, data: *const ::std::os::raw::c_void, length: usize) {
        SkMemoryStream_setMemoryOwned(self, data, length)
    }
    #[inline]
    pub unsafe fn setData(&mut self, data: sk_sp<SkData>) {
        SkMemoryStream_setData(self, data)
    }
    #[inline]
    pub unsafe fn skipToAlign4(&mut self) {
        SkMemoryStream_skipToAlign4(self)
    }
    #[inline]
    pub unsafe fn getAtPos(&mut self) -> *const ::std::os::raw::c_void {
        SkMemoryStream_getAtPos(self)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkMemoryStream_SkMemoryStream(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(length: usize) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkMemoryStream_SkMemoryStream1(&mut __bindgen_tmp, length);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new2(data: *const ::std::os::raw::c_void, length: usize, copyData: bool) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkMemoryStream_SkMemoryStream2(&mut __bindgen_tmp, data, length, copyData);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new3(data: sk_sp<SkData>) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkMemoryStream_SkMemoryStream3(&mut __bindgen_tmp, data);
        __bindgen_tmp
    }
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkMemoryStream9setMemoryEPKvmb"]
    pub fn SkMemoryStream_setMemory(
        this: *mut ::std::os::raw::c_void,
        data: *const ::std::os::raw::c_void,
        length: usize,
        copyData: bool,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkMemoryStream4readEPvm"]
    pub fn SkMemoryStream_read(
        this: *mut ::std::os::raw::c_void,
        buffer: *mut ::std::os::raw::c_void,
        size: usize,
    ) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZNK14SkMemoryStream7isAtEndEv"]
    pub fn SkMemoryStream_isAtEnd(this: *mut ::std::os::raw::c_void) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK14SkMemoryStream4peekEPvm"]
    pub fn SkMemoryStream_peek(
        this: *mut ::std::os::raw::c_void,
        buffer: *mut ::std::os::raw::c_void,
        size: usize,
    ) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkMemoryStream6rewindEv"]
    pub fn SkMemoryStream_rewind(this: *mut ::std::os::raw::c_void) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK14SkMemoryStream11getPositionEv"]
    pub fn SkMemoryStream_getPosition(this: *mut ::std::os::raw::c_void) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkMemoryStream4seekEm"]
    pub fn SkMemoryStream_seek(this: *mut ::std::os::raw::c_void, position: usize) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkMemoryStream4moveEl"]
    pub fn SkMemoryStream_move(
        this: *mut ::std::os::raw::c_void,
        offset: ::std::os::raw::c_long,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK14SkMemoryStream9getLengthEv"]
    pub fn SkMemoryStream_getLength(this: *mut ::std::os::raw::c_void) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkMemoryStream13getMemoryBaseEv"]
    pub fn SkMemoryStream_getMemoryBase(
        this: *mut ::std::os::raw::c_void,
    ) -> *const ::std::os::raw::c_void;
}
#[repr(C)]
pub struct SkDynamicMemoryWStream {
    pub _base: SkWStream,
    pub fHead: *mut SkDynamicMemoryWStream_Block,
    pub fTail: *mut SkDynamicMemoryWStream_Block,
    pub fBytesWrittenBeforeTail: usize,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkDynamicMemoryWStream_Block {
    _unused: [u8; 0],
}
pub type SkDynamicMemoryWStream_INHERITED = SkWStream;
#[test]
fn bindgen_test_layout_SkDynamicMemoryWStream() {
    assert_eq!(
        ::core::mem::size_of::<SkDynamicMemoryWStream>(),
        32usize,
        concat!("Size of: ", stringify!(SkDynamicMemoryWStream))
    );
    assert_eq!(
        ::core::mem::align_of::<SkDynamicMemoryWStream>(),
        8usize,
        concat!("Alignment of ", stringify!(SkDynamicMemoryWStream))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkDynamicMemoryWStream>())).fHead as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkDynamicMemoryWStream),
            "::",
            stringify!(fHead)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkDynamicMemoryWStream>())).fTail as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkDynamicMemoryWStream),
            "::",
            stringify!(fTail)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkDynamicMemoryWStream>())).fBytesWrittenBeforeTail as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkDynamicMemoryWStream),
            "::",
            stringify!(fBytesWrittenBeforeTail)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN22SkDynamicMemoryWStream4readEPvmm"]
    pub fn SkDynamicMemoryWStream_read(
        this: *mut SkDynamicMemoryWStream,
        buffer: *mut ::std::os::raw::c_void,
        offset: usize,
        size: usize,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK22SkDynamicMemoryWStream6copyToEPv"]
    pub fn SkDynamicMemoryWStream_copyTo(
        this: *const SkDynamicMemoryWStream,
        dst: *mut ::std::os::raw::c_void,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK22SkDynamicMemoryWStream13writeToStreamEP9SkWStream"]
    pub fn SkDynamicMemoryWStream_writeToStream(
        this: *const SkDynamicMemoryWStream,
        dst: *mut SkWStream,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN22SkDynamicMemoryWStream14copyToAndResetEPv"]
    pub fn SkDynamicMemoryWStream_copyToAndReset(
        this: *mut SkDynamicMemoryWStream,
        dst: *mut ::std::os::raw::c_void,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN22SkDynamicMemoryWStream15writeToAndResetEP9SkWStream"]
    pub fn SkDynamicMemoryWStream_writeToAndReset(
        this: *mut SkDynamicMemoryWStream,
        dst: *mut SkWStream,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN22SkDynamicMemoryWStream15writeToAndResetEPS_"]
    pub fn SkDynamicMemoryWStream_writeToAndReset1(
        this: *mut SkDynamicMemoryWStream,
        dst: *mut SkDynamicMemoryWStream,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN22SkDynamicMemoryWStream17prependToAndResetEPS_"]
    pub fn SkDynamicMemoryWStream_prependToAndReset(
        this: *mut SkDynamicMemoryWStream,
        dst: *mut SkDynamicMemoryWStream,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN22SkDynamicMemoryWStream12detachAsDataEv"]
    pub fn SkDynamicMemoryWStream_detachAsData(this: *mut SkDynamicMemoryWStream) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZN22SkDynamicMemoryWStream14detachAsStreamEv"]
    pub fn SkDynamicMemoryWStream_detachAsStream(this: *mut SkDynamicMemoryWStream) -> u64;
}
extern "C" {
    #[link_name = "\u{1}_ZN22SkDynamicMemoryWStream5resetEv"]
    pub fn SkDynamicMemoryWStream_reset(this: *mut SkDynamicMemoryWStream);
}
extern "C" {
    #[link_name = "\u{1}_ZN22SkDynamicMemoryWStream11padToAlign4Ev"]
    pub fn SkDynamicMemoryWStream_padToAlign4(this: *mut SkDynamicMemoryWStream);
}
extern "C" {
    #[link_name = "\u{1}_ZN22SkDynamicMemoryWStreamC1EOS_"]
    pub fn SkDynamicMemoryWStream_SkDynamicMemoryWStream(
        this: *mut SkDynamicMemoryWStream,
        arg1: *mut SkDynamicMemoryWStream,
    );
}
impl SkDynamicMemoryWStream {
    #[inline]
    pub unsafe fn read(
        &mut self,
        buffer: *mut ::std::os::raw::c_void,
        offset: usize,
        size: usize,
    ) -> bool {
        SkDynamicMemoryWStream_read(self, buffer, offset, size)
    }
    #[inline]
    pub unsafe fn copyTo(&self, dst: *mut ::std::os::raw::c_void) {
        SkDynamicMemoryWStream_copyTo(self, dst)
    }
    #[inline]
    pub unsafe fn writeToStream(&self, dst: *mut SkWStream) -> bool {
        SkDynamicMemoryWStream_writeToStream(self, dst)
    }
    #[inline]
    pub unsafe fn copyToAndReset(&mut self, dst: *mut ::std::os::raw::c_void) {
        SkDynamicMemoryWStream_copyToAndReset(self, dst)
    }
    #[inline]
    pub unsafe fn writeToAndReset(&mut self, dst: *mut SkWStream) -> bool {
        SkDynamicMemoryWStream_writeToAndReset(self, dst)
    }
    #[inline]
    pub unsafe fn writeToAndReset1(&mut self, dst: *mut SkDynamicMemoryWStream) -> bool {
        SkDynamicMemoryWStream_writeToAndReset1(self, dst)
    }
    #[inline]
    pub unsafe fn prependToAndReset(&mut self, dst: *mut SkDynamicMemoryWStream) {
        SkDynamicMemoryWStream_prependToAndReset(self, dst)
    }
    #[inline]
    pub unsafe fn detachAsData(&mut self) -> sk_sp<SkData> {
        SkDynamicMemoryWStream_detachAsData(self)
    }
    #[inline]
    pub unsafe fn detachAsStream(&mut self) -> u64 {
        SkDynamicMemoryWStream_detachAsStream(self)
    }
    #[inline]
    pub unsafe fn reset(&mut self) {
        SkDynamicMemoryWStream_reset(self)
    }
    #[inline]
    pub unsafe fn padToAlign4(&mut self) {
        SkDynamicMemoryWStream_padToAlign4(self)
    }
    #[inline]
    pub unsafe fn new(arg1: *mut SkDynamicMemoryWStream) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkDynamicMemoryWStream_SkDynamicMemoryWStream(&mut __bindgen_tmp, arg1);
        __bindgen_tmp
    }
}
extern "C" {
    #[link_name = "\u{1}_ZN22SkDynamicMemoryWStreamD1Ev"]
    pub fn SkDynamicMemoryWStream_SkDynamicMemoryWStream_destructor(
        this: *mut SkDynamicMemoryWStream,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN22SkDynamicMemoryWStream5writeEPKvm"]
    pub fn SkDynamicMemoryWStream_write(
        this: *mut ::std::os::raw::c_void,
        buffer: *const ::std::os::raw::c_void,
        size: usize,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK22SkDynamicMemoryWStream12bytesWrittenEv"]
    pub fn SkDynamicMemoryWStream_bytesWritten(this: *mut ::std::os::raw::c_void) -> usize;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkArenaAlloc {
    _unused: [u8; 0],
}
#[repr(C)]
pub struct SkShader {
    pub _base: SkFlattenable,
}
impl SkShader_GradientType {
    pub const kLast_GradientType: SkShader_GradientType =
        SkShader_GradientType::kConical_GradientType;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkShader_GradientType {
    kNone_GradientType = 0,
    kColor_GradientType = 1,
    kLinear_GradientType = 2,
    kRadial_GradientType = 3,
    kSweep_GradientType = 4,
    kConical_GradientType = 5,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkShader_GradientInfo {
    pub fColorCount: ::std::os::raw::c_int,
    pub fColors: *mut SkColor,
    pub fColorOffsets: *mut SkScalar,
    pub fPoint: [SkPoint; 2usize],
    pub fRadius: [SkScalar; 2usize],
    pub fTileMode: SkTileMode,
    pub fGradientFlags: u32,
}
#[test]
fn bindgen_test_layout_SkShader_GradientInfo() {
    assert_eq!(
        ::core::mem::size_of::<SkShader_GradientInfo>(),
        56usize,
        concat!("Size of: ", stringify!(SkShader_GradientInfo))
    );
    assert_eq!(
        ::core::mem::align_of::<SkShader_GradientInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(SkShader_GradientInfo))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkShader_GradientInfo>())).fColorCount as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkShader_GradientInfo),
            "::",
            stringify!(fColorCount)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkShader_GradientInfo>())).fColors as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkShader_GradientInfo),
            "::",
            stringify!(fColors)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkShader_GradientInfo>())).fColorOffsets as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkShader_GradientInfo),
            "::",
            stringify!(fColorOffsets)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkShader_GradientInfo>())).fPoint as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkShader_GradientInfo),
            "::",
            stringify!(fPoint)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkShader_GradientInfo>())).fRadius as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(SkShader_GradientInfo),
            "::",
            stringify!(fRadius)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkShader_GradientInfo>())).fTileMode as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(SkShader_GradientInfo),
            "::",
            stringify!(fTileMode)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkShader_GradientInfo>())).fGradientFlags as *const _ as usize
        },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(SkShader_GradientInfo),
            "::",
            stringify!(fGradientFlags)
        )
    );
}
pub type SkShader_INHERITED = SkFlattenable;
#[test]
fn bindgen_test_layout_SkShader() {
    assert_eq!(
        ::core::mem::size_of::<SkShader>(),
        16usize,
        concat!("Size of: ", stringify!(SkShader))
    );
    assert_eq!(
        ::core::mem::align_of::<SkShader>(),
        8usize,
        concat!("Alignment of ", stringify!(SkShader))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkShader8isAImageEP8SkMatrixP10SkTileMode"]
    pub fn SkShader_isAImage(
        this: *const SkShader,
        localMatrix: *mut SkMatrix,
        xy: *mut SkTileMode,
    ) -> *mut SkImage;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkShader19makeWithLocalMatrixERK8SkMatrix"]
    pub fn SkShader_makeWithLocalMatrix(
        this: *const SkShader,
        arg1: *const SkMatrix,
    ) -> sk_sp<SkShader>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkShader19makeWithColorFilterE5sk_spI13SkColorFilterE"]
    pub fn SkShader_makeWithColorFilter(
        this: *const SkShader,
        arg1: sk_sp<SkColorFilter>,
    ) -> sk_sp<SkShader>;
}
impl SkShader {
    #[inline]
    pub unsafe fn isAImage(&self, localMatrix: *mut SkMatrix, xy: *mut SkTileMode) -> *mut SkImage {
        SkShader_isAImage(self, localMatrix, xy)
    }
    #[inline]
    pub unsafe fn makeWithLocalMatrix(&self, arg1: *const SkMatrix) -> sk_sp<SkShader> {
        SkShader_makeWithLocalMatrix(self, arg1)
    }
    #[inline]
    pub unsafe fn makeWithColorFilter(&self, arg1: sk_sp<SkColorFilter>) -> sk_sp<SkShader> {
        SkShader_makeWithColorFilter(self, arg1)
    }
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkShader11asAGradientEPNS_12GradientInfoE"]
    pub fn SkShader_asAGradient(
        this: *mut ::std::os::raw::c_void,
        info: *mut SkShader_GradientInfo,
    ) -> SkShader_GradientType;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrTexture {
    _unused: [u8; 0],
}
#[repr(C)]
pub struct SkImage {
    pub _base: SkRefCnt,
    pub fInfo: SkImageInfo,
    pub fUniqueID: u32,
}
pub type SkImage_ReleaseContext = *mut ::std::os::raw::c_void;
pub type SkImage_RasterReleaseProc = ::core::option::Option<
    unsafe extern "C" fn(pixels: *const ::std::os::raw::c_void, arg1: SkImage_ReleaseContext),
>;
impl SkImage_CompressionType {
    pub const kLast_CompressionType: SkImage_CompressionType =
        SkImage_CompressionType::kETC1_CompressionType;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkImage_CompressionType {
    kETC1_CompressionType = 0,
}
pub type SkImage_TextureReleaseProc =
    ::core::option::Option<unsafe extern "C" fn(releaseContext: SkImage_ReleaseContext)>;
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkImage_BitDepth {
    kU8 = 0,
    kF16 = 1,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkImage_CachingHint {
    kAllow_CachingHint = 0,
    kDisallow_CachingHint = 1,
}
pub type SkImage_BackendTextureReleaseProc = u8;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkImage_LegacyBitmapMode {
    kRO_LegacyBitmapMode = 0,
}
pub type SkImage_INHERITED = SkRefCnt;
#[test]
fn bindgen_test_layout_SkImage() {
    assert_eq!(
        ::core::mem::size_of::<SkImage>(),
        48usize,
        concat!("Size of: ", stringify!(SkImage))
    );
    assert_eq!(
        ::core::mem::align_of::<SkImage>(),
        8usize,
        concat!("Alignment of ", stringify!(SkImage))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkImage>())).fInfo as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImage),
            "::",
            stringify!(fInfo)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkImage>())).fUniqueID as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImage),
            "::",
            stringify!(fUniqueID)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage14MakeRasterCopyERK8SkPixmap"]
    pub fn SkImage_MakeRasterCopy(pixmap: *const SkPixmap) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage14MakeRasterDataERK11SkImageInfo5sk_spI6SkDataEm"]
    pub fn SkImage_MakeRasterData(
        info: *const SkImageInfo,
        pixels: sk_sp<SkData>,
        rowBytes: usize,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage14MakeFromRasterERK8SkPixmapPFvPKvPvES5_"]
    pub fn SkImage_MakeFromRaster(
        pixmap: *const SkPixmap,
        rasterReleaseProc: SkImage_RasterReleaseProc,
        releaseContext: SkImage_ReleaseContext,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage14MakeFromBitmapERK8SkBitmap"]
    pub fn SkImage_MakeFromBitmap(bitmap: *const SkBitmap) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage17MakeFromGeneratorESt10unique_ptrI16SkImageGeneratorSt14default_deleteIS1_EEPK7SkIRect"]
    pub fn SkImage_MakeFromGenerator(imageGenerator: u64, subset: *const SkIRect)
        -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage15MakeFromEncodedE5sk_spI6SkDataEPK7SkIRect"]
    pub fn SkImage_MakeFromEncoded(
        encoded: sk_sp<SkData>,
        subset: *const SkIRect,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage18MakeFromCompressedEP9GrContext5sk_spI6SkDataEiiNS_15CompressionTypeE"]
    pub fn SkImage_MakeFromCompressed(
        context: *mut GrContext,
        data: sk_sp<SkData>,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        type_: SkImage_CompressionType,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage15MakeFromTextureEP9GrContextRK16GrBackendTexture15GrSurfaceOrigin11SkColorType11SkAlphaType5sk_spI12SkColorSpaceEPFvPvESB_"]
    pub fn SkImage_MakeFromTexture(
        context: *mut GrContext,
        backendTexture: *const GrBackendTexture,
        origin: GrSurfaceOrigin,
        colorType: SkColorType,
        alphaType: SkAlphaType,
        colorSpace: sk_sp<SkColorSpace>,
        textureReleaseProc: SkImage_TextureReleaseProc,
        releaseContext: SkImage_ReleaseContext,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage27MakeCrossContextFromEncodedEP9GrContext5sk_spI6SkDataEbP12SkColorSpaceb"]
    pub fn SkImage_MakeCrossContextFromEncoded(
        context: *mut GrContext,
        data: sk_sp<SkData>,
        buildMips: bool,
        dstColorSpace: *mut SkColorSpace,
        limitToMaxTextureSize: bool,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage26MakeCrossContextFromPixmapEP9GrContextRK8SkPixmapbP12SkColorSpaceb"]
    pub fn SkImage_MakeCrossContextFromPixmap(
        context: *mut GrContext,
        pixmap: *const SkPixmap,
        buildMips: bool,
        dstColorSpace: *mut SkColorSpace,
        limitToMaxTextureSize: bool,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage22MakeFromAdoptedTextureEP9GrContextRK16GrBackendTexture15GrSurfaceOrigin11SkColorType11SkAlphaType5sk_spI12SkColorSpaceE"]
    pub fn SkImage_MakeFromAdoptedTexture(
        context: *mut GrContext,
        backendTexture: *const GrBackendTexture,
        surfaceOrigin: GrSurfaceOrigin,
        colorType: SkColorType,
        alphaType: SkAlphaType,
        colorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage24MakeFromYUVATexturesCopyEP9GrContext15SkYUVColorSpacePK16GrBackendTexturePK11SkYUVAIndex7SkISize15GrSurfaceOrigin5sk_spI12SkColorSpaceE"]
    pub fn SkImage_MakeFromYUVATexturesCopy(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        yuvaTextures: *const GrBackendTexture,
        yuvaIndices: *const SkYUVAIndex,
        imageSize: SkISize,
        imageOrigin: GrSurfaceOrigin,
        imageColorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage43MakeFromYUVATexturesCopyWithExternalBackendEP9GrContext15SkYUVColorSpacePK16GrBackendTexturePK11SkYUVAIndex7SkISize15GrSurfaceOriginRS4_5sk_spI12SkColorSpaceE"]
    pub fn SkImage_MakeFromYUVATexturesCopyWithExternalBackend(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        yuvaTextures: *const GrBackendTexture,
        yuvaIndices: *const SkYUVAIndex,
        imageSize: SkISize,
        imageOrigin: GrSurfaceOrigin,
        backendTexture: *const GrBackendTexture,
        imageColorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage20MakeFromYUVATexturesEP9GrContext15SkYUVColorSpacePK16GrBackendTexturePK11SkYUVAIndex7SkISize15GrSurfaceOrigin5sk_spI12SkColorSpaceE"]
    pub fn SkImage_MakeFromYUVATextures(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        yuvaTextures: *const GrBackendTexture,
        yuvaIndices: *const SkYUVAIndex,
        imageSize: SkISize,
        imageOrigin: GrSurfaceOrigin,
        imageColorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage19MakeFromYUVAPixmapsEP9GrContext15SkYUVColorSpacePK8SkPixmapPK11SkYUVAIndex7SkISize15GrSurfaceOriginbb5sk_spI12SkColorSpaceE"]
    pub fn SkImage_MakeFromYUVAPixmaps(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        yuvaPixmaps: *const SkPixmap,
        yuvaIndices: *const SkYUVAIndex,
        imageSize: SkISize,
        imageOrigin: GrSurfaceOrigin,
        buildMips: bool,
        limitToMaxTextureSize: bool,
        imageColorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage23MakeFromYUVTexturesCopyEP9GrContext15SkYUVColorSpacePK16GrBackendTexture15GrSurfaceOrigin5sk_spI12SkColorSpaceE"]
    pub fn SkImage_MakeFromYUVTexturesCopy(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        yuvTextures: *const GrBackendTexture,
        imageOrigin: GrSurfaceOrigin,
        imageColorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage42MakeFromYUVTexturesCopyWithExternalBackendEP9GrContext15SkYUVColorSpacePK16GrBackendTexture15GrSurfaceOriginRS4_5sk_spI12SkColorSpaceE"]
    pub fn SkImage_MakeFromYUVTexturesCopyWithExternalBackend(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        yuvTextures: *const GrBackendTexture,
        imageOrigin: GrSurfaceOrigin,
        backendTexture: *const GrBackendTexture,
        imageColorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage24MakeFromNV12TexturesCopyEP9GrContext15SkYUVColorSpacePK16GrBackendTexture15GrSurfaceOrigin5sk_spI12SkColorSpaceE"]
    pub fn SkImage_MakeFromNV12TexturesCopy(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        nv12Textures: *const GrBackendTexture,
        imageOrigin: GrSurfaceOrigin,
        imageColorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage43MakeFromNV12TexturesCopyWithExternalBackendEP9GrContext15SkYUVColorSpacePK16GrBackendTexture15GrSurfaceOriginRS4_5sk_spI12SkColorSpaceE"]
    pub fn SkImage_MakeFromNV12TexturesCopyWithExternalBackend(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        nv12Textures: *const GrBackendTexture,
        imageOrigin: GrSurfaceOrigin,
        backendTexture: *const GrBackendTexture,
        imageColorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage15MakeFromPictureE5sk_spI9SkPictureERK7SkISizePK8SkMatrixPK7SkPaintNS_8BitDepthES0_I12SkColorSpaceE"]
    pub fn SkImage_MakeFromPicture(
        picture: sk_sp<SkPicture>,
        dimensions: *const SkISize,
        matrix: *const SkMatrix,
        paint: *const SkPaint,
        bitDepth: SkImage_BitDepth,
        colorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage9alphaTypeEv"]
    pub fn SkImage_alphaType(this: *const SkImage) -> SkAlphaType;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage9colorTypeEv"]
    pub fn SkImage_colorType(this: *const SkImage) -> SkColorType;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage10colorSpaceEv"]
    pub fn SkImage_colorSpace(this: *const SkImage) -> *mut SkColorSpace;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage13refColorSpaceEv"]
    pub fn SkImage_refColorSpace(this: *const SkImage) -> sk_sp<SkColorSpace>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage11isAlphaOnlyEv"]
    pub fn SkImage_isAlphaOnly(this: *const SkImage) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage10makeShaderE10SkTileModeS0_PK8SkMatrix"]
    pub fn SkImage_makeShader(
        this: *const SkImage,
        tmx: SkTileMode,
        tmy: SkTileMode,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage10peekPixelsEP8SkPixmap"]
    pub fn SkImage_peekPixels(this: *const SkImage, pixmap: *mut SkPixmap) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage10getTextureEv"]
    pub fn SkImage_getTexture(this: *const SkImage) -> *mut GrTexture;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage15isTextureBackedEv"]
    pub fn SkImage_isTextureBacked(this: *const SkImage) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage7isValidEP9GrContext"]
    pub fn SkImage_isValid(this: *const SkImage, context: *mut GrContext) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage5flushEP9GrContextRK11GrFlushInfo"]
    pub fn SkImage_flush(
        this: *mut SkImage,
        context: *mut GrContext,
        flushInfo: *const GrFlushInfo,
    ) -> GrSemaphoresSubmitted;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage5flushEP9GrContext"]
    pub fn SkImage_flush1(this: *mut SkImage, arg1: *mut GrContext);
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage17getBackendTextureEbP15GrSurfaceOrigin"]
    pub fn SkImage_getBackendTexture(
        this: *const SkImage,
        flushPendingGrContextIO: bool,
        origin: *mut GrSurfaceOrigin,
    ) -> GrBackendTexture;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage10readPixelsERK11SkImageInfoPvmiiNS_11CachingHintE"]
    pub fn SkImage_readPixels(
        this: *const SkImage,
        dstInfo: *const SkImageInfo,
        dstPixels: *mut ::std::os::raw::c_void,
        dstRowBytes: usize,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
        cachingHint: SkImage_CachingHint,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage10readPixelsERK8SkPixmapiiNS_11CachingHintE"]
    pub fn SkImage_readPixels1(
        this: *const SkImage,
        dst: *const SkPixmap,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
        cachingHint: SkImage_CachingHint,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage11scalePixelsERK8SkPixmap15SkFilterQualityNS_11CachingHintE"]
    pub fn SkImage_scalePixels(
        this: *const SkImage,
        dst: *const SkPixmap,
        filterQuality: SkFilterQuality,
        cachingHint: SkImage_CachingHint,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage12encodeToDataE20SkEncodedImageFormati"]
    pub fn SkImage_encodeToData(
        this: *const SkImage,
        encodedImageFormat: SkEncodedImageFormat,
        quality: ::std::os::raw::c_int,
    ) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage12encodeToDataEv"]
    pub fn SkImage_encodeToData1(this: *const SkImage) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage14refEncodedDataEv"]
    pub fn SkImage_refEncodedData(this: *const SkImage) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage10makeSubsetERK7SkIRect"]
    pub fn SkImage_makeSubset(this: *const SkImage, subset: *const SkIRect) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage16makeTextureImageEP9GrContextP12SkColorSpace11GrMipMapped"]
    pub fn SkImage_makeTextureImage(
        this: *const SkImage,
        context: *mut GrContext,
        dstColorSpace: *mut SkColorSpace,
        mipMapped: GrMipMapped,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage19makeNonTextureImageEv"]
    pub fn SkImage_makeNonTextureImage(this: *const SkImage) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage15makeRasterImageEv"]
    pub fn SkImage_makeRasterImage(this: *const SkImage) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage14makeWithFilterEP9GrContextPK13SkImageFilterRK7SkIRectS7_PS5_P8SkIPoint"]
    pub fn SkImage_makeWithFilter(
        this: *const SkImage,
        context: *mut GrContext,
        filter: *const SkImageFilter,
        subset: *const SkIRect,
        clipBounds: *const SkIRect,
        outSubset: *mut SkIRect,
        offset: *mut SkIPoint,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage14makeWithFilterEPK13SkImageFilterRK7SkIRectS5_PS3_P8SkIPoint"]
    pub fn SkImage_makeWithFilter1(
        this: *const SkImage,
        filter: *const SkImageFilter,
        subset: *const SkIRect,
        clipBounds: *const SkIRect,
        outSubset: *mut SkIRect,
        offset: *mut SkIPoint,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN7SkImage29MakeBackendTextureFromSkImageEP9GrContext5sk_spIS_EP16GrBackendTexturePSt8functionIFvS4_EE"]
    pub fn SkImage_MakeBackendTextureFromSkImage(
        context: *mut GrContext,
        image: sk_sp<SkImage>,
        backendTexture: *mut GrBackendTexture,
        backendTextureReleaseProc: *mut SkImage_BackendTextureReleaseProc,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage14asLegacyBitmapEP8SkBitmapNS_16LegacyBitmapModeE"]
    pub fn SkImage_asLegacyBitmap(
        this: *const SkImage,
        bitmap: *mut SkBitmap,
        legacyBitmapMode: SkImage_LegacyBitmapMode,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage15isLazyGeneratedEv"]
    pub fn SkImage_isLazyGenerated(this: *const SkImage) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage14makeColorSpaceE5sk_spI12SkColorSpaceE"]
    pub fn SkImage_makeColorSpace(
        this: *const SkImage,
        target: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK7SkImage26makeColorTypeAndColorSpaceE11SkColorType5sk_spI12SkColorSpaceE"]
    pub fn SkImage_makeColorTypeAndColorSpace(
        this: *const SkImage,
        targetColorType: SkColorType,
        targetColorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage>;
}
impl SkImage {
    #[inline]
    pub unsafe fn MakeRasterCopy(pixmap: *const SkPixmap) -> sk_sp<SkImage> {
        SkImage_MakeRasterCopy(pixmap)
    }
    #[inline]
    pub unsafe fn MakeRasterData(
        info: *const SkImageInfo,
        pixels: sk_sp<SkData>,
        rowBytes: usize,
    ) -> sk_sp<SkImage> {
        SkImage_MakeRasterData(info, pixels, rowBytes)
    }
    #[inline]
    pub unsafe fn MakeFromRaster(
        pixmap: *const SkPixmap,
        rasterReleaseProc: SkImage_RasterReleaseProc,
        releaseContext: SkImage_ReleaseContext,
    ) -> sk_sp<SkImage> {
        SkImage_MakeFromRaster(pixmap, rasterReleaseProc, releaseContext)
    }
    #[inline]
    pub unsafe fn MakeFromBitmap(bitmap: *const SkBitmap) -> sk_sp<SkImage> {
        SkImage_MakeFromBitmap(bitmap)
    }
    #[inline]
    pub unsafe fn MakeFromGenerator(imageGenerator: u64, subset: *const SkIRect) -> sk_sp<SkImage> {
        SkImage_MakeFromGenerator(imageGenerator, subset)
    }
    #[inline]
    pub unsafe fn MakeFromEncoded(
        encoded: sk_sp<SkData>,
        subset: *const SkIRect,
    ) -> sk_sp<SkImage> {
        SkImage_MakeFromEncoded(encoded, subset)
    }
    #[inline]
    pub unsafe fn MakeFromCompressed(
        context: *mut GrContext,
        data: sk_sp<SkData>,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        type_: SkImage_CompressionType,
    ) -> sk_sp<SkImage> {
        SkImage_MakeFromCompressed(context, data, width, height, type_)
    }
    #[inline]
    pub unsafe fn MakeFromTexture(
        context: *mut GrContext,
        backendTexture: *const GrBackendTexture,
        origin: GrSurfaceOrigin,
        colorType: SkColorType,
        alphaType: SkAlphaType,
        colorSpace: sk_sp<SkColorSpace>,
        textureReleaseProc: SkImage_TextureReleaseProc,
        releaseContext: SkImage_ReleaseContext,
    ) -> sk_sp<SkImage> {
        SkImage_MakeFromTexture(
            context,
            backendTexture,
            origin,
            colorType,
            alphaType,
            colorSpace,
            textureReleaseProc,
            releaseContext,
        )
    }
    #[inline]
    pub unsafe fn MakeCrossContextFromEncoded(
        context: *mut GrContext,
        data: sk_sp<SkData>,
        buildMips: bool,
        dstColorSpace: *mut SkColorSpace,
        limitToMaxTextureSize: bool,
    ) -> sk_sp<SkImage> {
        SkImage_MakeCrossContextFromEncoded(
            context,
            data,
            buildMips,
            dstColorSpace,
            limitToMaxTextureSize,
        )
    }
    #[inline]
    pub unsafe fn MakeCrossContextFromPixmap(
        context: *mut GrContext,
        pixmap: *const SkPixmap,
        buildMips: bool,
        dstColorSpace: *mut SkColorSpace,
        limitToMaxTextureSize: bool,
    ) -> sk_sp<SkImage> {
        SkImage_MakeCrossContextFromPixmap(
            context,
            pixmap,
            buildMips,
            dstColorSpace,
            limitToMaxTextureSize,
        )
    }
    #[inline]
    pub unsafe fn MakeFromAdoptedTexture(
        context: *mut GrContext,
        backendTexture: *const GrBackendTexture,
        surfaceOrigin: GrSurfaceOrigin,
        colorType: SkColorType,
        alphaType: SkAlphaType,
        colorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage> {
        SkImage_MakeFromAdoptedTexture(
            context,
            backendTexture,
            surfaceOrigin,
            colorType,
            alphaType,
            colorSpace,
        )
    }
    #[inline]
    pub unsafe fn MakeFromYUVATexturesCopy(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        yuvaTextures: *const GrBackendTexture,
        yuvaIndices: *const SkYUVAIndex,
        imageSize: SkISize,
        imageOrigin: GrSurfaceOrigin,
        imageColorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage> {
        SkImage_MakeFromYUVATexturesCopy(
            context,
            yuvColorSpace,
            yuvaTextures,
            yuvaIndices,
            imageSize,
            imageOrigin,
            imageColorSpace,
        )
    }
    #[inline]
    pub unsafe fn MakeFromYUVATexturesCopyWithExternalBackend(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        yuvaTextures: *const GrBackendTexture,
        yuvaIndices: *const SkYUVAIndex,
        imageSize: SkISize,
        imageOrigin: GrSurfaceOrigin,
        backendTexture: *const GrBackendTexture,
        imageColorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage> {
        SkImage_MakeFromYUVATexturesCopyWithExternalBackend(
            context,
            yuvColorSpace,
            yuvaTextures,
            yuvaIndices,
            imageSize,
            imageOrigin,
            backendTexture,
            imageColorSpace,
        )
    }
    #[inline]
    pub unsafe fn MakeFromYUVATextures(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        yuvaTextures: *const GrBackendTexture,
        yuvaIndices: *const SkYUVAIndex,
        imageSize: SkISize,
        imageOrigin: GrSurfaceOrigin,
        imageColorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage> {
        SkImage_MakeFromYUVATextures(
            context,
            yuvColorSpace,
            yuvaTextures,
            yuvaIndices,
            imageSize,
            imageOrigin,
            imageColorSpace,
        )
    }
    #[inline]
    pub unsafe fn MakeFromYUVAPixmaps(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        yuvaPixmaps: *const SkPixmap,
        yuvaIndices: *const SkYUVAIndex,
        imageSize: SkISize,
        imageOrigin: GrSurfaceOrigin,
        buildMips: bool,
        limitToMaxTextureSize: bool,
        imageColorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage> {
        SkImage_MakeFromYUVAPixmaps(
            context,
            yuvColorSpace,
            yuvaPixmaps,
            yuvaIndices,
            imageSize,
            imageOrigin,
            buildMips,
            limitToMaxTextureSize,
            imageColorSpace,
        )
    }
    #[inline]
    pub unsafe fn MakeFromYUVTexturesCopy(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        yuvTextures: *const GrBackendTexture,
        imageOrigin: GrSurfaceOrigin,
        imageColorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage> {
        SkImage_MakeFromYUVTexturesCopy(
            context,
            yuvColorSpace,
            yuvTextures,
            imageOrigin,
            imageColorSpace,
        )
    }
    #[inline]
    pub unsafe fn MakeFromYUVTexturesCopyWithExternalBackend(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        yuvTextures: *const GrBackendTexture,
        imageOrigin: GrSurfaceOrigin,
        backendTexture: *const GrBackendTexture,
        imageColorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage> {
        SkImage_MakeFromYUVTexturesCopyWithExternalBackend(
            context,
            yuvColorSpace,
            yuvTextures,
            imageOrigin,
            backendTexture,
            imageColorSpace,
        )
    }
    #[inline]
    pub unsafe fn MakeFromNV12TexturesCopy(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        nv12Textures: *const GrBackendTexture,
        imageOrigin: GrSurfaceOrigin,
        imageColorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage> {
        SkImage_MakeFromNV12TexturesCopy(
            context,
            yuvColorSpace,
            nv12Textures,
            imageOrigin,
            imageColorSpace,
        )
    }
    #[inline]
    pub unsafe fn MakeFromNV12TexturesCopyWithExternalBackend(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        nv12Textures: *const GrBackendTexture,
        imageOrigin: GrSurfaceOrigin,
        backendTexture: *const GrBackendTexture,
        imageColorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage> {
        SkImage_MakeFromNV12TexturesCopyWithExternalBackend(
            context,
            yuvColorSpace,
            nv12Textures,
            imageOrigin,
            backendTexture,
            imageColorSpace,
        )
    }
    #[inline]
    pub unsafe fn MakeFromPicture(
        picture: sk_sp<SkPicture>,
        dimensions: *const SkISize,
        matrix: *const SkMatrix,
        paint: *const SkPaint,
        bitDepth: SkImage_BitDepth,
        colorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage> {
        SkImage_MakeFromPicture(picture, dimensions, matrix, paint, bitDepth, colorSpace)
    }
    #[inline]
    pub unsafe fn alphaType(&self) -> SkAlphaType {
        SkImage_alphaType(self)
    }
    #[inline]
    pub unsafe fn colorType(&self) -> SkColorType {
        SkImage_colorType(self)
    }
    #[inline]
    pub unsafe fn colorSpace(&self) -> *mut SkColorSpace {
        SkImage_colorSpace(self)
    }
    #[inline]
    pub unsafe fn refColorSpace(&self) -> sk_sp<SkColorSpace> {
        SkImage_refColorSpace(self)
    }
    #[inline]
    pub unsafe fn isAlphaOnly(&self) -> bool {
        SkImage_isAlphaOnly(self)
    }
    #[inline]
    pub unsafe fn makeShader(
        &self,
        tmx: SkTileMode,
        tmy: SkTileMode,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader> {
        SkImage_makeShader(self, tmx, tmy, localMatrix)
    }
    #[inline]
    pub unsafe fn peekPixels(&self, pixmap: *mut SkPixmap) -> bool {
        SkImage_peekPixels(self, pixmap)
    }
    #[inline]
    pub unsafe fn getTexture(&self) -> *mut GrTexture {
        SkImage_getTexture(self)
    }
    #[inline]
    pub unsafe fn isTextureBacked(&self) -> bool {
        SkImage_isTextureBacked(self)
    }
    #[inline]
    pub unsafe fn isValid(&self, context: *mut GrContext) -> bool {
        SkImage_isValid(self, context)
    }
    #[inline]
    pub unsafe fn flush(
        &mut self,
        context: *mut GrContext,
        flushInfo: *const GrFlushInfo,
    ) -> GrSemaphoresSubmitted {
        SkImage_flush(self, context, flushInfo)
    }
    #[inline]
    pub unsafe fn flush1(&mut self, arg1: *mut GrContext) {
        SkImage_flush1(self, arg1)
    }
    #[inline]
    pub unsafe fn getBackendTexture(
        &self,
        flushPendingGrContextIO: bool,
        origin: *mut GrSurfaceOrigin,
    ) -> GrBackendTexture {
        SkImage_getBackendTexture(self, flushPendingGrContextIO, origin)
    }
    #[inline]
    pub unsafe fn readPixels(
        &self,
        dstInfo: *const SkImageInfo,
        dstPixels: *mut ::std::os::raw::c_void,
        dstRowBytes: usize,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
        cachingHint: SkImage_CachingHint,
    ) -> bool {
        SkImage_readPixels(
            self,
            dstInfo,
            dstPixels,
            dstRowBytes,
            srcX,
            srcY,
            cachingHint,
        )
    }
    #[inline]
    pub unsafe fn readPixels1(
        &self,
        dst: *const SkPixmap,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
        cachingHint: SkImage_CachingHint,
    ) -> bool {
        SkImage_readPixels1(self, dst, srcX, srcY, cachingHint)
    }
    #[inline]
    pub unsafe fn scalePixels(
        &self,
        dst: *const SkPixmap,
        filterQuality: SkFilterQuality,
        cachingHint: SkImage_CachingHint,
    ) -> bool {
        SkImage_scalePixels(self, dst, filterQuality, cachingHint)
    }
    #[inline]
    pub unsafe fn encodeToData(
        &self,
        encodedImageFormat: SkEncodedImageFormat,
        quality: ::std::os::raw::c_int,
    ) -> sk_sp<SkData> {
        SkImage_encodeToData(self, encodedImageFormat, quality)
    }
    #[inline]
    pub unsafe fn encodeToData1(&self) -> sk_sp<SkData> {
        SkImage_encodeToData1(self)
    }
    #[inline]
    pub unsafe fn refEncodedData(&self) -> sk_sp<SkData> {
        SkImage_refEncodedData(self)
    }
    #[inline]
    pub unsafe fn makeSubset(&self, subset: *const SkIRect) -> sk_sp<SkImage> {
        SkImage_makeSubset(self, subset)
    }
    #[inline]
    pub unsafe fn makeTextureImage(
        &self,
        context: *mut GrContext,
        dstColorSpace: *mut SkColorSpace,
        mipMapped: GrMipMapped,
    ) -> sk_sp<SkImage> {
        SkImage_makeTextureImage(self, context, dstColorSpace, mipMapped)
    }
    #[inline]
    pub unsafe fn makeNonTextureImage(&self) -> sk_sp<SkImage> {
        SkImage_makeNonTextureImage(self)
    }
    #[inline]
    pub unsafe fn makeRasterImage(&self) -> sk_sp<SkImage> {
        SkImage_makeRasterImage(self)
    }
    #[inline]
    pub unsafe fn makeWithFilter(
        &self,
        context: *mut GrContext,
        filter: *const SkImageFilter,
        subset: *const SkIRect,
        clipBounds: *const SkIRect,
        outSubset: *mut SkIRect,
        offset: *mut SkIPoint,
    ) -> sk_sp<SkImage> {
        SkImage_makeWithFilter(self, context, filter, subset, clipBounds, outSubset, offset)
    }
    #[inline]
    pub unsafe fn makeWithFilter1(
        &self,
        filter: *const SkImageFilter,
        subset: *const SkIRect,
        clipBounds: *const SkIRect,
        outSubset: *mut SkIRect,
        offset: *mut SkIPoint,
    ) -> sk_sp<SkImage> {
        SkImage_makeWithFilter1(self, filter, subset, clipBounds, outSubset, offset)
    }
    #[inline]
    pub unsafe fn MakeBackendTextureFromSkImage(
        context: *mut GrContext,
        image: sk_sp<SkImage>,
        backendTexture: *mut GrBackendTexture,
        backendTextureReleaseProc: *mut SkImage_BackendTextureReleaseProc,
    ) -> bool {
        SkImage_MakeBackendTextureFromSkImage(
            context,
            image,
            backendTexture,
            backendTextureReleaseProc,
        )
    }
    #[inline]
    pub unsafe fn asLegacyBitmap(
        &self,
        bitmap: *mut SkBitmap,
        legacyBitmapMode: SkImage_LegacyBitmapMode,
    ) -> bool {
        SkImage_asLegacyBitmap(self, bitmap, legacyBitmapMode)
    }
    #[inline]
    pub unsafe fn isLazyGenerated(&self) -> bool {
        SkImage_isLazyGenerated(self)
    }
    #[inline]
    pub unsafe fn makeColorSpace(&self, target: sk_sp<SkColorSpace>) -> sk_sp<SkImage> {
        SkImage_makeColorSpace(self, target)
    }
    #[inline]
    pub unsafe fn makeColorTypeAndColorSpace(
        &self,
        targetColorType: SkColorType,
        targetColorSpace: sk_sp<SkColorSpace>,
    ) -> sk_sp<SkImage> {
        SkImage_makeColorTypeAndColorSpace(self, targetColorType, targetColorSpace)
    }
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub struct SkWeakRefCnt {
    pub _bindgen_opaque_blob: [u64; 2usize],
}
pub type SkWeakRefCnt_INHERITED = SkRefCnt;
#[test]
fn bindgen_test_layout_SkWeakRefCnt() {
    assert_eq!(
        ::core::mem::size_of::<SkWeakRefCnt>(),
        16usize,
        concat!("Size of: ", stringify!(SkWeakRefCnt))
    );
    assert_eq!(
        ::core::mem::align_of::<SkWeakRefCnt>(),
        8usize,
        concat!("Alignment of ", stringify!(SkWeakRefCnt))
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrCaps {
    _unused: [u8; 0],
}
impl GrPixelConfig {
    pub const kLast_GrPixelConfig: GrPixelConfig = GrPixelConfig::kRG_half_GrPixelConfig;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum GrPixelConfig {
    kUnknown_GrPixelConfig = 0,
    kAlpha_8_GrPixelConfig = 1,
    kAlpha_8_as_Alpha_GrPixelConfig = 2,
    kAlpha_8_as_Red_GrPixelConfig = 3,
    kGray_8_GrPixelConfig = 4,
    kGray_8_as_Lum_GrPixelConfig = 5,
    kGray_8_as_Red_GrPixelConfig = 6,
    kRGB_565_GrPixelConfig = 7,
    kRGBA_4444_GrPixelConfig = 8,
    kRGBA_8888_GrPixelConfig = 9,
    kRGB_888_GrPixelConfig = 10,
    kRGB_888X_GrPixelConfig = 11,
    kRG_88_GrPixelConfig = 12,
    kBGRA_8888_GrPixelConfig = 13,
    kSRGBA_8888_GrPixelConfig = 14,
    kRGBA_1010102_GrPixelConfig = 15,
    kRGBA_float_GrPixelConfig = 16,
    kAlpha_half_GrPixelConfig = 17,
    kAlpha_half_as_Lum_GrPixelConfig = 18,
    kAlpha_half_as_Red_GrPixelConfig = 19,
    kRGBA_half_GrPixelConfig = 20,
    kRGBA_half_Clamped_GrPixelConfig = 21,
    kRGB_ETC1_GrPixelConfig = 22,
    kR_16_GrPixelConfig = 23,
    kRG_1616_GrPixelConfig = 24,
    kRGBA_16161616_GrPixelConfig = 25,
    kRG_half_GrPixelConfig = 26,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum GrTextureType {
    kNone = 0,
    k2D = 1,
    kRectangle = 2,
    kExternal = 3,
}
impl GrColorType {
    pub const kLast: GrColorType = GrColorType::kRG_F16;
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum GrColorType {
    kUnknown = 0,
    kAlpha_8 = 1,
    kBGR_565 = 2,
    kABGR_4444 = 3,
    kRGBA_8888 = 4,
    kRGBA_8888_SRGB = 5,
    kRGB_888x = 6,
    kRG_88 = 7,
    kBGRA_8888 = 8,
    kRGBA_1010102 = 9,
    kGray_8 = 10,
    kAlpha_F16 = 11,
    kRGBA_F16 = 12,
    kRGBA_F16_Clamped = 13,
    kRGBA_F32 = 14,
    kR_16 = 15,
    kRG_1616 = 16,
    kRGBA_16161616 = 17,
    kRG_F16 = 18,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrMockTextureInfo {
    pub fColorType: GrColorType,
    pub fID: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_GrMockTextureInfo() {
    assert_eq!(
        ::core::mem::size_of::<GrMockTextureInfo>(),
        8usize,
        concat!("Size of: ", stringify!(GrMockTextureInfo))
    );
    assert_eq!(
        ::core::mem::align_of::<GrMockTextureInfo>(),
        4usize,
        concat!("Alignment of ", stringify!(GrMockTextureInfo))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrMockTextureInfo>())).fColorType as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockTextureInfo),
            "::",
            stringify!(fColorType)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrMockTextureInfo>())).fID as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockTextureInfo),
            "::",
            stringify!(fID)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK17GrMockTextureInfo16getBackendFormatEv"]
    pub fn GrMockTextureInfo_getBackendFormat(this: *const GrMockTextureInfo) -> GrBackendFormat;
}
impl GrMockTextureInfo {
    #[inline]
    pub unsafe fn getBackendFormat(&self) -> GrBackendFormat {
        GrMockTextureInfo_getBackendFormat(self)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrMockRenderTargetInfo {
    pub fColorType: GrColorType,
    pub fID: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_GrMockRenderTargetInfo() {
    assert_eq!(
        ::core::mem::size_of::<GrMockRenderTargetInfo>(),
        8usize,
        concat!("Size of: ", stringify!(GrMockRenderTargetInfo))
    );
    assert_eq!(
        ::core::mem::align_of::<GrMockRenderTargetInfo>(),
        4usize,
        concat!("Alignment of ", stringify!(GrMockRenderTargetInfo))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrMockRenderTargetInfo>())).fColorType as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockRenderTargetInfo),
            "::",
            stringify!(fColorType)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrMockRenderTargetInfo>())).fID as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockRenderTargetInfo),
            "::",
            stringify!(fID)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK22GrMockRenderTargetInfo16getBackendFormatEv"]
    pub fn GrMockRenderTargetInfo_getBackendFormat(
        this: *const GrMockRenderTargetInfo,
    ) -> GrBackendFormat;
}
impl GrMockRenderTargetInfo {
    #[inline]
    pub unsafe fn getBackendFormat(&self) -> GrBackendFormat {
        GrMockRenderTargetInfo_getBackendFormat(self)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrMockOptions {
    pub fInstanceAttribSupport: bool,
    pub fHalfFloatVertexAttributeSupport: bool,
    pub fMapBufferFlags: u32,
    pub fMaxTextureSize: ::std::os::raw::c_int,
    pub fMaxRenderTargetSize: ::std::os::raw::c_int,
    pub fMaxVertexAttributes: ::std::os::raw::c_int,
    pub fConfigOptions: [GrMockOptions_ConfigOptions; 19usize],
    pub fGeometryShaderSupport: bool,
    pub fIntegerSupport: bool,
    pub fFlatInterpolationSupport: bool,
    pub fMaxVertexSamplers: ::std::os::raw::c_int,
    pub fMaxFragmentSamplers: ::std::os::raw::c_int,
    pub fShaderDerivativeSupport: bool,
    pub fDualSourceBlendingSupport: bool,
    pub fFailTextureAllocations: bool,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrMockOptions_ConfigOptions {
    pub fRenderability: GrMockOptions_ConfigOptions_Renderability,
    pub fTexturable: bool,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum GrMockOptions_ConfigOptions_Renderability {
    kNo = 0,
    kNonMSAA = 1,
    kMSAA = 2,
}
#[test]
fn bindgen_test_layout_GrMockOptions_ConfigOptions() {
    assert_eq!(
        ::core::mem::size_of::<GrMockOptions_ConfigOptions>(),
        8usize,
        concat!("Size of: ", stringify!(GrMockOptions_ConfigOptions))
    );
    assert_eq!(
        ::core::mem::align_of::<GrMockOptions_ConfigOptions>(),
        4usize,
        concat!("Alignment of ", stringify!(GrMockOptions_ConfigOptions))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrMockOptions_ConfigOptions>())).fRenderability as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockOptions_ConfigOptions),
            "::",
            stringify!(fRenderability)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrMockOptions_ConfigOptions>())).fTexturable as *const _
                as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockOptions_ConfigOptions),
            "::",
            stringify!(fTexturable)
        )
    );
}
#[test]
fn bindgen_test_layout_GrMockOptions() {
    assert_eq!(
        ::core::mem::size_of::<GrMockOptions>(),
        188usize,
        concat!("Size of: ", stringify!(GrMockOptions))
    );
    assert_eq!(
        ::core::mem::align_of::<GrMockOptions>(),
        4usize,
        concat!("Alignment of ", stringify!(GrMockOptions))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrMockOptions>())).fInstanceAttribSupport as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockOptions),
            "::",
            stringify!(fInstanceAttribSupport)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrMockOptions>())).fHalfFloatVertexAttributeSupport as *const _
                as usize
        },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockOptions),
            "::",
            stringify!(fHalfFloatVertexAttributeSupport)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrMockOptions>())).fMapBufferFlags as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockOptions),
            "::",
            stringify!(fMapBufferFlags)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrMockOptions>())).fMaxTextureSize as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockOptions),
            "::",
            stringify!(fMaxTextureSize)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrMockOptions>())).fMaxRenderTargetSize as *const _ as usize
        },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockOptions),
            "::",
            stringify!(fMaxRenderTargetSize)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrMockOptions>())).fMaxVertexAttributes as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockOptions),
            "::",
            stringify!(fMaxVertexAttributes)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrMockOptions>())).fConfigOptions as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockOptions),
            "::",
            stringify!(fConfigOptions)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrMockOptions>())).fGeometryShaderSupport as *const _ as usize
        },
        172usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockOptions),
            "::",
            stringify!(fGeometryShaderSupport)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrMockOptions>())).fIntegerSupport as *const _ as usize },
        173usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockOptions),
            "::",
            stringify!(fIntegerSupport)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrMockOptions>())).fFlatInterpolationSupport as *const _
                as usize
        },
        174usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockOptions),
            "::",
            stringify!(fFlatInterpolationSupport)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrMockOptions>())).fMaxVertexSamplers as *const _ as usize
        },
        176usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockOptions),
            "::",
            stringify!(fMaxVertexSamplers)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrMockOptions>())).fMaxFragmentSamplers as *const _ as usize
        },
        180usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockOptions),
            "::",
            stringify!(fMaxFragmentSamplers)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrMockOptions>())).fShaderDerivativeSupport as *const _ as usize
        },
        184usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockOptions),
            "::",
            stringify!(fShaderDerivativeSupport)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrMockOptions>())).fDualSourceBlendingSupport as *const _
                as usize
        },
        185usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockOptions),
            "::",
            stringify!(fDualSourceBlendingSupport)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrMockOptions>())).fFailTextureAllocations as *const _ as usize
        },
        186usize,
        concat!(
            "Offset of field: ",
            stringify!(GrMockOptions),
            "::",
            stringify!(fFailTextureAllocations)
        )
    );
}
pub type VkFlags = u32;
pub type VkBool32 = u32;
pub type VkDeviceSize = u64;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct VkCommandBuffer_T {
    _unused: [u8; 0],
}
pub type VkCommandBuffer = *mut VkCommandBuffer_T;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct VkDeviceMemory_T {
    _unused: [u8; 0],
}
pub type VkDeviceMemory = *mut VkDeviceMemory_T;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct VkImage_T {
    _unused: [u8; 0],
}
pub type VkImage = *mut VkImage_T;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct VkRenderPass_T {
    _unused: [u8; 0],
}
pub type VkRenderPass = *mut VkRenderPass_T;
impl VkFormat {
    pub const G8B8G8R8_422_UNORM_KHR: VkFormat = VkFormat::G8B8G8R8_422_UNORM;
}
impl VkFormat {
    pub const B8G8R8G8_422_UNORM_KHR: VkFormat = VkFormat::B8G8R8G8_422_UNORM;
}
impl VkFormat {
    pub const G8_B8_R8_3PLANE_420_UNORM_KHR: VkFormat = VkFormat::G8_B8_R8_3PLANE_420_UNORM;
}
impl VkFormat {
    pub const G8_B8R8_2PLANE_420_UNORM_KHR: VkFormat = VkFormat::G8_B8R8_2PLANE_420_UNORM;
}
impl VkFormat {
    pub const G8_B8_R8_3PLANE_422_UNORM_KHR: VkFormat = VkFormat::G8_B8_R8_3PLANE_422_UNORM;
}
impl VkFormat {
    pub const G8_B8R8_2PLANE_422_UNORM_KHR: VkFormat = VkFormat::G8_B8R8_2PLANE_422_UNORM;
}
impl VkFormat {
    pub const G8_B8_R8_3PLANE_444_UNORM_KHR: VkFormat = VkFormat::G8_B8_R8_3PLANE_444_UNORM;
}
impl VkFormat {
    pub const R10X6_UNORM_PACK16_KHR: VkFormat = VkFormat::R10X6_UNORM_PACK16;
}
impl VkFormat {
    pub const R10X6G10X6_UNORM_2PACK16_KHR: VkFormat = VkFormat::R10X6G10X6_UNORM_2PACK16;
}
impl VkFormat {
    pub const R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: VkFormat =
        VkFormat::R10X6G10X6B10X6A10X6_UNORM_4PACK16;
}
impl VkFormat {
    pub const G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: VkFormat =
        VkFormat::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16;
}
impl VkFormat {
    pub const B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: VkFormat =
        VkFormat::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16;
}
impl VkFormat {
    pub const G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: VkFormat =
        VkFormat::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16;
}
impl VkFormat {
    pub const G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: VkFormat =
        VkFormat::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16;
}
impl VkFormat {
    pub const G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: VkFormat =
        VkFormat::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16;
}
impl VkFormat {
    pub const G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: VkFormat =
        VkFormat::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16;
}
impl VkFormat {
    pub const G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: VkFormat =
        VkFormat::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16;
}
impl VkFormat {
    pub const R12X4_UNORM_PACK16_KHR: VkFormat = VkFormat::R12X4_UNORM_PACK16;
}
impl VkFormat {
    pub const R12X4G12X4_UNORM_2PACK16_KHR: VkFormat = VkFormat::R12X4G12X4_UNORM_2PACK16;
}
impl VkFormat {
    pub const R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: VkFormat =
        VkFormat::R12X4G12X4B12X4A12X4_UNORM_4PACK16;
}
impl VkFormat {
    pub const G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: VkFormat =
        VkFormat::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16;
}
impl VkFormat {
    pub const B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: VkFormat =
        VkFormat::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16;
}
impl VkFormat {
    pub const G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: VkFormat =
        VkFormat::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16;
}
impl VkFormat {
    pub const G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: VkFormat =
        VkFormat::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16;
}
impl VkFormat {
    pub const G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: VkFormat =
        VkFormat::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16;
}
impl VkFormat {
    pub const G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: VkFormat =
        VkFormat::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16;
}
impl VkFormat {
    pub const G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: VkFormat =
        VkFormat::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16;
}
impl VkFormat {
    pub const G16B16G16R16_422_UNORM_KHR: VkFormat = VkFormat::G16B16G16R16_422_UNORM;
}
impl VkFormat {
    pub const B16G16R16G16_422_UNORM_KHR: VkFormat = VkFormat::B16G16R16G16_422_UNORM;
}
impl VkFormat {
    pub const G16_B16_R16_3PLANE_420_UNORM_KHR: VkFormat = VkFormat::G16_B16_R16_3PLANE_420_UNORM;
}
impl VkFormat {
    pub const G16_B16R16_2PLANE_420_UNORM_KHR: VkFormat = VkFormat::G16_B16R16_2PLANE_420_UNORM;
}
impl VkFormat {
    pub const G16_B16_R16_3PLANE_422_UNORM_KHR: VkFormat = VkFormat::G16_B16_R16_3PLANE_422_UNORM;
}
impl VkFormat {
    pub const G16_B16R16_2PLANE_422_UNORM_KHR: VkFormat = VkFormat::G16_B16R16_2PLANE_422_UNORM;
}
impl VkFormat {
    pub const G16_B16_R16_3PLANE_444_UNORM_KHR: VkFormat = VkFormat::G16_B16_R16_3PLANE_444_UNORM;
}
impl VkFormat {
    pub const BEGIN_RANGE: VkFormat = VkFormat::UNDEFINED;
}
impl VkFormat {
    pub const END_RANGE: VkFormat = VkFormat::ASTC_12x12_SRGB_BLOCK;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum VkFormat {
    UNDEFINED = 0,
    R4G4_UNORM_PACK8 = 1,
    R4G4B4A4_UNORM_PACK16 = 2,
    B4G4R4A4_UNORM_PACK16 = 3,
    R5G6B5_UNORM_PACK16 = 4,
    B5G6R5_UNORM_PACK16 = 5,
    R5G5B5A1_UNORM_PACK16 = 6,
    B5G5R5A1_UNORM_PACK16 = 7,
    A1R5G5B5_UNORM_PACK16 = 8,
    R8_UNORM = 9,
    R8_SNORM = 10,
    R8_USCALED = 11,
    R8_SSCALED = 12,
    R8_UINT = 13,
    R8_SINT = 14,
    R8_SRGB = 15,
    R8G8_UNORM = 16,
    R8G8_SNORM = 17,
    R8G8_USCALED = 18,
    R8G8_SSCALED = 19,
    R8G8_UINT = 20,
    R8G8_SINT = 21,
    R8G8_SRGB = 22,
    R8G8B8_UNORM = 23,
    R8G8B8_SNORM = 24,
    R8G8B8_USCALED = 25,
    R8G8B8_SSCALED = 26,
    R8G8B8_UINT = 27,
    R8G8B8_SINT = 28,
    R8G8B8_SRGB = 29,
    B8G8R8_UNORM = 30,
    B8G8R8_SNORM = 31,
    B8G8R8_USCALED = 32,
    B8G8R8_SSCALED = 33,
    B8G8R8_UINT = 34,
    B8G8R8_SINT = 35,
    B8G8R8_SRGB = 36,
    R8G8B8A8_UNORM = 37,
    R8G8B8A8_SNORM = 38,
    R8G8B8A8_USCALED = 39,
    R8G8B8A8_SSCALED = 40,
    R8G8B8A8_UINT = 41,
    R8G8B8A8_SINT = 42,
    R8G8B8A8_SRGB = 43,
    B8G8R8A8_UNORM = 44,
    B8G8R8A8_SNORM = 45,
    B8G8R8A8_USCALED = 46,
    B8G8R8A8_SSCALED = 47,
    B8G8R8A8_UINT = 48,
    B8G8R8A8_SINT = 49,
    B8G8R8A8_SRGB = 50,
    A8B8G8R8_UNORM_PACK32 = 51,
    A8B8G8R8_SNORM_PACK32 = 52,
    A8B8G8R8_USCALED_PACK32 = 53,
    A8B8G8R8_SSCALED_PACK32 = 54,
    A8B8G8R8_UINT_PACK32 = 55,
    A8B8G8R8_SINT_PACK32 = 56,
    A8B8G8R8_SRGB_PACK32 = 57,
    A2R10G10B10_UNORM_PACK32 = 58,
    A2R10G10B10_SNORM_PACK32 = 59,
    A2R10G10B10_USCALED_PACK32 = 60,
    A2R10G10B10_SSCALED_PACK32 = 61,
    A2R10G10B10_UINT_PACK32 = 62,
    A2R10G10B10_SINT_PACK32 = 63,
    A2B10G10R10_UNORM_PACK32 = 64,
    A2B10G10R10_SNORM_PACK32 = 65,
    A2B10G10R10_USCALED_PACK32 = 66,
    A2B10G10R10_SSCALED_PACK32 = 67,
    A2B10G10R10_UINT_PACK32 = 68,
    A2B10G10R10_SINT_PACK32 = 69,
    R16_UNORM = 70,
    R16_SNORM = 71,
    R16_USCALED = 72,
    R16_SSCALED = 73,
    R16_UINT = 74,
    R16_SINT = 75,
    R16_SFLOAT = 76,
    R16G16_UNORM = 77,
    R16G16_SNORM = 78,
    R16G16_USCALED = 79,
    R16G16_SSCALED = 80,
    R16G16_UINT = 81,
    R16G16_SINT = 82,
    R16G16_SFLOAT = 83,
    R16G16B16_UNORM = 84,
    R16G16B16_SNORM = 85,
    R16G16B16_USCALED = 86,
    R16G16B16_SSCALED = 87,
    R16G16B16_UINT = 88,
    R16G16B16_SINT = 89,
    R16G16B16_SFLOAT = 90,
    R16G16B16A16_UNORM = 91,
    R16G16B16A16_SNORM = 92,
    R16G16B16A16_USCALED = 93,
    R16G16B16A16_SSCALED = 94,
    R16G16B16A16_UINT = 95,
    R16G16B16A16_SINT = 96,
    R16G16B16A16_SFLOAT = 97,
    R32_UINT = 98,
    R32_SINT = 99,
    R32_SFLOAT = 100,
    R32G32_UINT = 101,
    R32G32_SINT = 102,
    R32G32_SFLOAT = 103,
    R32G32B32_UINT = 104,
    R32G32B32_SINT = 105,
    R32G32B32_SFLOAT = 106,
    R32G32B32A32_UINT = 107,
    R32G32B32A32_SINT = 108,
    R32G32B32A32_SFLOAT = 109,
    R64_UINT = 110,
    R64_SINT = 111,
    R64_SFLOAT = 112,
    R64G64_UINT = 113,
    R64G64_SINT = 114,
    R64G64_SFLOAT = 115,
    R64G64B64_UINT = 116,
    R64G64B64_SINT = 117,
    R64G64B64_SFLOAT = 118,
    R64G64B64A64_UINT = 119,
    R64G64B64A64_SINT = 120,
    R64G64B64A64_SFLOAT = 121,
    B10G11R11_UFLOAT_PACK32 = 122,
    E5B9G9R9_UFLOAT_PACK32 = 123,
    D16_UNORM = 124,
    X8_D24_UNORM_PACK32 = 125,
    D32_SFLOAT = 126,
    S8_UINT = 127,
    D16_UNORM_S8_UINT = 128,
    D24_UNORM_S8_UINT = 129,
    D32_SFLOAT_S8_UINT = 130,
    BC1_RGB_UNORM_BLOCK = 131,
    BC1_RGB_SRGB_BLOCK = 132,
    BC1_RGBA_UNORM_BLOCK = 133,
    BC1_RGBA_SRGB_BLOCK = 134,
    BC2_UNORM_BLOCK = 135,
    BC2_SRGB_BLOCK = 136,
    BC3_UNORM_BLOCK = 137,
    BC3_SRGB_BLOCK = 138,
    BC4_UNORM_BLOCK = 139,
    BC4_SNORM_BLOCK = 140,
    BC5_UNORM_BLOCK = 141,
    BC5_SNORM_BLOCK = 142,
    BC6H_UFLOAT_BLOCK = 143,
    BC6H_SFLOAT_BLOCK = 144,
    BC7_UNORM_BLOCK = 145,
    BC7_SRGB_BLOCK = 146,
    ETC2_R8G8B8_UNORM_BLOCK = 147,
    ETC2_R8G8B8_SRGB_BLOCK = 148,
    ETC2_R8G8B8A1_UNORM_BLOCK = 149,
    ETC2_R8G8B8A1_SRGB_BLOCK = 150,
    ETC2_R8G8B8A8_UNORM_BLOCK = 151,
    ETC2_R8G8B8A8_SRGB_BLOCK = 152,
    EAC_R11_UNORM_BLOCK = 153,
    EAC_R11_SNORM_BLOCK = 154,
    EAC_R11G11_UNORM_BLOCK = 155,
    EAC_R11G11_SNORM_BLOCK = 156,
    ASTC_4x4_UNORM_BLOCK = 157,
    ASTC_4x4_SRGB_BLOCK = 158,
    ASTC_5x4_UNORM_BLOCK = 159,
    ASTC_5x4_SRGB_BLOCK = 160,
    ASTC_5x5_UNORM_BLOCK = 161,
    ASTC_5x5_SRGB_BLOCK = 162,
    ASTC_6x5_UNORM_BLOCK = 163,
    ASTC_6x5_SRGB_BLOCK = 164,
    ASTC_6x6_UNORM_BLOCK = 165,
    ASTC_6x6_SRGB_BLOCK = 166,
    ASTC_8x5_UNORM_BLOCK = 167,
    ASTC_8x5_SRGB_BLOCK = 168,
    ASTC_8x6_UNORM_BLOCK = 169,
    ASTC_8x6_SRGB_BLOCK = 170,
    ASTC_8x8_UNORM_BLOCK = 171,
    ASTC_8x8_SRGB_BLOCK = 172,
    ASTC_10x5_UNORM_BLOCK = 173,
    ASTC_10x5_SRGB_BLOCK = 174,
    ASTC_10x6_UNORM_BLOCK = 175,
    ASTC_10x6_SRGB_BLOCK = 176,
    ASTC_10x8_UNORM_BLOCK = 177,
    ASTC_10x8_SRGB_BLOCK = 178,
    ASTC_10x10_UNORM_BLOCK = 179,
    ASTC_10x10_SRGB_BLOCK = 180,
    ASTC_12x10_UNORM_BLOCK = 181,
    ASTC_12x10_SRGB_BLOCK = 182,
    ASTC_12x12_UNORM_BLOCK = 183,
    ASTC_12x12_SRGB_BLOCK = 184,
    G8B8G8R8_422_UNORM = 1000156000,
    B8G8R8G8_422_UNORM = 1000156001,
    G8_B8_R8_3PLANE_420_UNORM = 1000156002,
    G8_B8R8_2PLANE_420_UNORM = 1000156003,
    G8_B8_R8_3PLANE_422_UNORM = 1000156004,
    G8_B8R8_2PLANE_422_UNORM = 1000156005,
    G8_B8_R8_3PLANE_444_UNORM = 1000156006,
    R10X6_UNORM_PACK16 = 1000156007,
    R10X6G10X6_UNORM_2PACK16 = 1000156008,
    R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009,
    G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010,
    B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011,
    G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012,
    G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013,
    G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014,
    G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015,
    G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016,
    R12X4_UNORM_PACK16 = 1000156017,
    R12X4G12X4_UNORM_2PACK16 = 1000156018,
    R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019,
    G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020,
    B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021,
    G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022,
    G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023,
    G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024,
    G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025,
    G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026,
    G16B16G16R16_422_UNORM = 1000156027,
    B16G16R16G16_422_UNORM = 1000156028,
    G16_B16_R16_3PLANE_420_UNORM = 1000156029,
    G16_B16R16_2PLANE_420_UNORM = 1000156030,
    G16_B16_R16_3PLANE_422_UNORM = 1000156031,
    G16_B16R16_2PLANE_422_UNORM = 1000156032,
    G16_B16_R16_3PLANE_444_UNORM = 1000156033,
    PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000,
    PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001,
    PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002,
    PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003,
    PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004,
    PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
    PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
    PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
    RANGE_SIZE = 185,
    MAX_ENUM = 2147483647,
}
impl VkImageTiling {
    pub const BEGIN_RANGE: VkImageTiling = VkImageTiling::OPTIMAL;
}
impl VkImageTiling {
    pub const END_RANGE: VkImageTiling = VkImageTiling::LINEAR;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum VkImageTiling {
    OPTIMAL = 0,
    LINEAR = 1,
    RANGE_SIZE = 2,
    MAX_ENUM = 2147483647,
}
impl VkImageLayout {
    pub const DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR: VkImageLayout =
        VkImageLayout::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL;
}
impl VkImageLayout {
    pub const DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR: VkImageLayout =
        VkImageLayout::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL;
}
impl VkImageLayout {
    pub const BEGIN_RANGE: VkImageLayout = VkImageLayout::UNDEFINED;
}
impl VkImageLayout {
    pub const END_RANGE: VkImageLayout = VkImageLayout::PREINITIALIZED;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum VkImageLayout {
    UNDEFINED = 0,
    GENERAL = 1,
    COLOR_ATTACHMENT_OPTIMAL = 2,
    DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
    DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
    SHADER_READ_ONLY_OPTIMAL = 5,
    TRANSFER_SRC_OPTIMAL = 6,
    TRANSFER_DST_OPTIMAL = 7,
    PREINITIALIZED = 8,
    DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000,
    DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001,
    PRESENT_SRC_KHR = 1000001002,
    SHARED_PRESENT_KHR = 1000111000,
    RANGE_SIZE = 9,
    MAX_ENUM = 2147483647,
}
impl VkFilter {
    pub const BEGIN_RANGE: VkFilter = VkFilter::NEAREST;
}
impl VkFilter {
    pub const END_RANGE: VkFilter = VkFilter::LINEAR;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum VkFilter {
    NEAREST = 0,
    LINEAR = 1,
    CUBIC_IMG = 1000015000,
    RANGE_SIZE = 2,
    MAX_ENUM = 2147483647,
}
pub type VkFormatFeatureFlags = VkFlags;
#[repr(C)]
#[repr(align(4))]
pub struct VkPhysicalDeviceFeatures {
    pub _bindgen_opaque_blob: [u32; 55usize],
}
#[test]
fn bindgen_test_layout_VkPhysicalDeviceFeatures() {
    assert_eq!(
        ::core::mem::size_of::<VkPhysicalDeviceFeatures>(),
        220usize,
        concat!("Size of: ", stringify!(VkPhysicalDeviceFeatures))
    );
    assert_eq!(
        ::core::mem::align_of::<VkPhysicalDeviceFeatures>(),
        4usize,
        concat!("Alignment of ", stringify!(VkPhysicalDeviceFeatures))
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct VkOffset2D {
    pub x: i32,
    pub y: i32,
}
#[test]
fn bindgen_test_layout_VkOffset2D() {
    assert_eq!(
        ::core::mem::size_of::<VkOffset2D>(),
        8usize,
        concat!("Size of: ", stringify!(VkOffset2D))
    );
    assert_eq!(
        ::core::mem::align_of::<VkOffset2D>(),
        4usize,
        concat!("Alignment of ", stringify!(VkOffset2D))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<VkOffset2D>())).x as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(VkOffset2D),
            "::",
            stringify!(x)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<VkOffset2D>())).y as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(VkOffset2D),
            "::",
            stringify!(y)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct VkExtent2D {
    pub width: u32,
    pub height: u32,
}
#[test]
fn bindgen_test_layout_VkExtent2D() {
    assert_eq!(
        ::core::mem::size_of::<VkExtent2D>(),
        8usize,
        concat!("Size of: ", stringify!(VkExtent2D))
    );
    assert_eq!(
        ::core::mem::align_of::<VkExtent2D>(),
        4usize,
        concat!("Alignment of ", stringify!(VkExtent2D))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<VkExtent2D>())).width as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(VkExtent2D),
            "::",
            stringify!(width)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<VkExtent2D>())).height as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(VkExtent2D),
            "::",
            stringify!(height)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct VkRect2D {
    pub offset: VkOffset2D,
    pub extent: VkExtent2D,
}
#[test]
fn bindgen_test_layout_VkRect2D() {
    assert_eq!(
        ::core::mem::size_of::<VkRect2D>(),
        16usize,
        concat!("Size of: ", stringify!(VkRect2D))
    );
    assert_eq!(
        ::core::mem::align_of::<VkRect2D>(),
        4usize,
        concat!("Alignment of ", stringify!(VkRect2D))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<VkRect2D>())).offset as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(VkRect2D),
            "::",
            stringify!(offset)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<VkRect2D>())).extent as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(VkRect2D),
            "::",
            stringify!(extent)
        )
    );
}
impl VkSamplerYcbcrModelConversion {
    pub const RGB_IDENTITY_KHR: VkSamplerYcbcrModelConversion =
        VkSamplerYcbcrModelConversion::RGB_IDENTITY;
}
impl VkSamplerYcbcrModelConversion {
    pub const YCBCR_IDENTITY_KHR: VkSamplerYcbcrModelConversion =
        VkSamplerYcbcrModelConversion::YCBCR_IDENTITY;
}
impl VkSamplerYcbcrModelConversion {
    pub const YCBCR_709_KHR: VkSamplerYcbcrModelConversion =
        VkSamplerYcbcrModelConversion::YCBCR_709;
}
impl VkSamplerYcbcrModelConversion {
    pub const YCBCR_601_KHR: VkSamplerYcbcrModelConversion =
        VkSamplerYcbcrModelConversion::YCBCR_601;
}
impl VkSamplerYcbcrModelConversion {
    pub const YCBCR_2020_KHR: VkSamplerYcbcrModelConversion =
        VkSamplerYcbcrModelConversion::YCBCR_2020;
}
impl VkSamplerYcbcrModelConversion {
    pub const BEGIN_RANGE: VkSamplerYcbcrModelConversion =
        VkSamplerYcbcrModelConversion::RGB_IDENTITY;
}
impl VkSamplerYcbcrModelConversion {
    pub const END_RANGE: VkSamplerYcbcrModelConversion = VkSamplerYcbcrModelConversion::YCBCR_2020;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum VkSamplerYcbcrModelConversion {
    RGB_IDENTITY = 0,
    YCBCR_IDENTITY = 1,
    YCBCR_709 = 2,
    YCBCR_601 = 3,
    YCBCR_2020 = 4,
    RANGE_SIZE = 5,
    MAX_ENUM = 2147483647,
}
impl VkSamplerYcbcrRange {
    pub const ITU_FULL_KHR: VkSamplerYcbcrRange = VkSamplerYcbcrRange::ITU_FULL;
}
impl VkSamplerYcbcrRange {
    pub const ITU_NARROW_KHR: VkSamplerYcbcrRange = VkSamplerYcbcrRange::ITU_NARROW;
}
impl VkSamplerYcbcrRange {
    pub const BEGIN_RANGE: VkSamplerYcbcrRange = VkSamplerYcbcrRange::ITU_FULL;
}
impl VkSamplerYcbcrRange {
    pub const END_RANGE: VkSamplerYcbcrRange = VkSamplerYcbcrRange::ITU_NARROW;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum VkSamplerYcbcrRange {
    ITU_FULL = 0,
    ITU_NARROW = 1,
    RANGE_SIZE = 2,
    MAX_ENUM = 2147483647,
}
impl VkChromaLocation {
    pub const COSITED_EVEN_KHR: VkChromaLocation = VkChromaLocation::COSITED_EVEN;
}
impl VkChromaLocation {
    pub const MIDPOINT_KHR: VkChromaLocation = VkChromaLocation::MIDPOINT;
}
impl VkChromaLocation {
    pub const BEGIN_RANGE: VkChromaLocation = VkChromaLocation::COSITED_EVEN;
}
impl VkChromaLocation {
    pub const END_RANGE: VkChromaLocation = VkChromaLocation::MIDPOINT;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum VkChromaLocation {
    COSITED_EVEN = 0,
    MIDPOINT = 1,
    RANGE_SIZE = 2,
    MAX_ENUM = 2147483647,
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub struct VkPhysicalDeviceFeatures2 {
    pub _bindgen_opaque_blob: [u64; 30usize],
}
#[test]
fn bindgen_test_layout_VkPhysicalDeviceFeatures2() {
    assert_eq!(
        ::core::mem::size_of::<VkPhysicalDeviceFeatures2>(),
        240usize,
        concat!("Size of: ", stringify!(VkPhysicalDeviceFeatures2))
    );
    assert_eq!(
        ::core::mem::align_of::<VkPhysicalDeviceFeatures2>(),
        8usize,
        concat!("Alignment of ", stringify!(VkPhysicalDeviceFeatures2))
    );
}
pub type GrVkBackendMemory = isize;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrVkAlloc {
    pub fMemory: VkDeviceMemory,
    pub fOffset: VkDeviceSize,
    pub fSize: VkDeviceSize,
    pub fFlags: u32,
    pub fBackendMemory: GrVkBackendMemory,
    pub fUsesSystemHeap: bool,
}
pub const GrVkAlloc_Flag_kNoncoherent_Flag: GrVkAlloc_Flag = 1;
pub const GrVkAlloc_Flag_kMappable_Flag: GrVkAlloc_Flag = 2;
pub type GrVkAlloc_Flag = u32;
#[test]
fn bindgen_test_layout_GrVkAlloc() {
    assert_eq!(
        ::core::mem::size_of::<GrVkAlloc>(),
        48usize,
        concat!("Size of: ", stringify!(GrVkAlloc))
    );
    assert_eq!(
        ::core::mem::align_of::<GrVkAlloc>(),
        8usize,
        concat!("Alignment of ", stringify!(GrVkAlloc))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrVkAlloc>())).fMemory as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkAlloc),
            "::",
            stringify!(fMemory)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrVkAlloc>())).fOffset as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkAlloc),
            "::",
            stringify!(fOffset)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrVkAlloc>())).fSize as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkAlloc),
            "::",
            stringify!(fSize)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrVkAlloc>())).fFlags as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkAlloc),
            "::",
            stringify!(fFlags)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrVkAlloc>())).fBackendMemory as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkAlloc),
            "::",
            stringify!(fBackendMemory)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrVkAlloc>())).fUsesSystemHeap as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkAlloc),
            "::",
            stringify!(fUsesSystemHeap)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrVkYcbcrConversionInfo {
    pub fYcbcrModel: VkSamplerYcbcrModelConversion,
    pub fYcbcrRange: VkSamplerYcbcrRange,
    pub fXChromaOffset: VkChromaLocation,
    pub fYChromaOffset: VkChromaLocation,
    pub fChromaFilter: VkFilter,
    pub fForceExplicitReconstruction: VkBool32,
    pub fExternalFormat: u64,
    pub fExternalFormatFeatures: VkFormatFeatureFlags,
}
#[test]
fn bindgen_test_layout_GrVkYcbcrConversionInfo() {
    assert_eq!(
        ::core::mem::size_of::<GrVkYcbcrConversionInfo>(),
        40usize,
        concat!("Size of: ", stringify!(GrVkYcbcrConversionInfo))
    );
    assert_eq!(
        ::core::mem::align_of::<GrVkYcbcrConversionInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(GrVkYcbcrConversionInfo))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrVkYcbcrConversionInfo>())).fYcbcrModel as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkYcbcrConversionInfo),
            "::",
            stringify!(fYcbcrModel)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrVkYcbcrConversionInfo>())).fYcbcrRange as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkYcbcrConversionInfo),
            "::",
            stringify!(fYcbcrRange)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrVkYcbcrConversionInfo>())).fXChromaOffset as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkYcbcrConversionInfo),
            "::",
            stringify!(fXChromaOffset)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrVkYcbcrConversionInfo>())).fYChromaOffset as *const _ as usize
        },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkYcbcrConversionInfo),
            "::",
            stringify!(fYChromaOffset)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrVkYcbcrConversionInfo>())).fChromaFilter as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkYcbcrConversionInfo),
            "::",
            stringify!(fChromaFilter)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrVkYcbcrConversionInfo>())).fForceExplicitReconstruction
                as *const _ as usize
        },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkYcbcrConversionInfo),
            "::",
            stringify!(fForceExplicitReconstruction)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrVkYcbcrConversionInfo>())).fExternalFormat as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkYcbcrConversionInfo),
            "::",
            stringify!(fExternalFormat)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrVkYcbcrConversionInfo>())).fExternalFormatFeatures as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkYcbcrConversionInfo),
            "::",
            stringify!(fExternalFormatFeatures)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrVkImageInfo {
    pub fImage: VkImage,
    pub fAlloc: GrVkAlloc,
    pub fImageTiling: VkImageTiling,
    pub fImageLayout: VkImageLayout,
    pub fFormat: VkFormat,
    pub fLevelCount: u32,
    pub fCurrentQueueFamily: u32,
    pub fProtected: GrProtected,
    pub fYcbcrConversionInfo: GrVkYcbcrConversionInfo,
}
#[test]
fn bindgen_test_layout_GrVkImageInfo() {
    assert_eq!(
        ::core::mem::size_of::<GrVkImageInfo>(),
        120usize,
        concat!("Size of: ", stringify!(GrVkImageInfo))
    );
    assert_eq!(
        ::core::mem::align_of::<GrVkImageInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(GrVkImageInfo))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrVkImageInfo>())).fImage as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkImageInfo),
            "::",
            stringify!(fImage)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrVkImageInfo>())).fAlloc as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkImageInfo),
            "::",
            stringify!(fAlloc)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrVkImageInfo>())).fImageTiling as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkImageInfo),
            "::",
            stringify!(fImageTiling)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrVkImageInfo>())).fImageLayout as *const _ as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkImageInfo),
            "::",
            stringify!(fImageLayout)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrVkImageInfo>())).fFormat as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkImageInfo),
            "::",
            stringify!(fFormat)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrVkImageInfo>())).fLevelCount as *const _ as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkImageInfo),
            "::",
            stringify!(fLevelCount)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrVkImageInfo>())).fCurrentQueueFamily as *const _ as usize
        },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkImageInfo),
            "::",
            stringify!(fCurrentQueueFamily)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrVkImageInfo>())).fProtected as *const _ as usize },
        76usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkImageInfo),
            "::",
            stringify!(fProtected)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrVkImageInfo>())).fYcbcrConversionInfo as *const _ as usize
        },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkImageInfo),
            "::",
            stringify!(fYcbcrConversionInfo)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrVkDrawableInfo {
    pub fSecondaryCommandBuffer: VkCommandBuffer,
    pub fColorAttachmentIndex: u32,
    pub fCompatibleRenderPass: VkRenderPass,
    pub fFormat: VkFormat,
    pub fDrawBounds: *mut VkRect2D,
    pub fImage: VkImage,
}
#[test]
fn bindgen_test_layout_GrVkDrawableInfo() {
    assert_eq!(
        ::core::mem::size_of::<GrVkDrawableInfo>(),
        48usize,
        concat!("Size of: ", stringify!(GrVkDrawableInfo))
    );
    assert_eq!(
        ::core::mem::align_of::<GrVkDrawableInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(GrVkDrawableInfo))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrVkDrawableInfo>())).fSecondaryCommandBuffer as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkDrawableInfo),
            "::",
            stringify!(fSecondaryCommandBuffer)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrVkDrawableInfo>())).fColorAttachmentIndex as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkDrawableInfo),
            "::",
            stringify!(fColorAttachmentIndex)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrVkDrawableInfo>())).fCompatibleRenderPass as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkDrawableInfo),
            "::",
            stringify!(fCompatibleRenderPass)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrVkDrawableInfo>())).fFormat as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkDrawableInfo),
            "::",
            stringify!(fFormat)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrVkDrawableInfo>())).fDrawBounds as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkDrawableInfo),
            "::",
            stringify!(fDrawBounds)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrVkDrawableInfo>())).fImage as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkDrawableInfo),
            "::",
            stringify!(fImage)
        )
    );
}
#[repr(C)]
pub struct GrGLTextureParameters {
    pub _base: SkNVRefCnt,
    pub fSamplerOverriddenState: GrGLTextureParameters_SamplerOverriddenState,
    pub fNonsamplerState: GrGLTextureParameters_NonsamplerState,
    pub fResetTimestamp: GrGLTextureParameters_ResetTimestamp,
}
pub type GrGLTextureParameters_ResetTimestamp = u64;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrGLTextureParameters_SamplerOverriddenState {
    pub fMinFilter: GrGLenum,
    pub fMagFilter: GrGLenum,
    pub fWrapS: GrGLenum,
    pub fWrapT: GrGLenum,
    pub fMinLOD: GrGLfloat,
    pub fMaxLOD: GrGLfloat,
    pub fBorderColorInvalid: bool,
}
#[test]
fn bindgen_test_layout_GrGLTextureParameters_SamplerOverriddenState() {
    assert_eq!(
        ::core::mem::size_of::<GrGLTextureParameters_SamplerOverriddenState>(),
        28usize,
        concat!(
            "Size of: ",
            stringify!(GrGLTextureParameters_SamplerOverriddenState)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<GrGLTextureParameters_SamplerOverriddenState>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(GrGLTextureParameters_SamplerOverriddenState)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrGLTextureParameters_SamplerOverriddenState>())).fMinFilter
                as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLTextureParameters_SamplerOverriddenState),
            "::",
            stringify!(fMinFilter)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrGLTextureParameters_SamplerOverriddenState>())).fMagFilter
                as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLTextureParameters_SamplerOverriddenState),
            "::",
            stringify!(fMagFilter)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrGLTextureParameters_SamplerOverriddenState>())).fWrapS
                as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLTextureParameters_SamplerOverriddenState),
            "::",
            stringify!(fWrapS)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrGLTextureParameters_SamplerOverriddenState>())).fWrapT
                as *const _ as usize
        },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLTextureParameters_SamplerOverriddenState),
            "::",
            stringify!(fWrapT)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrGLTextureParameters_SamplerOverriddenState>())).fMinLOD
                as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLTextureParameters_SamplerOverriddenState),
            "::",
            stringify!(fMinLOD)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrGLTextureParameters_SamplerOverriddenState>())).fMaxLOD
                as *const _ as usize
        },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLTextureParameters_SamplerOverriddenState),
            "::",
            stringify!(fMaxLOD)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrGLTextureParameters_SamplerOverriddenState>()))
                .fBorderColorInvalid as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLTextureParameters_SamplerOverriddenState),
            "::",
            stringify!(fBorderColorInvalid)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN21GrGLTextureParameters22SamplerOverriddenState10invalidateEv"]
    pub fn GrGLTextureParameters_SamplerOverriddenState_invalidate(
        this: *mut GrGLTextureParameters_SamplerOverriddenState,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN21GrGLTextureParameters22SamplerOverriddenStateC1Ev"]
    pub fn GrGLTextureParameters_SamplerOverriddenState_SamplerOverriddenState(
        this: *mut GrGLTextureParameters_SamplerOverriddenState,
    );
}
impl GrGLTextureParameters_SamplerOverriddenState {
    #[inline]
    pub unsafe fn invalidate(&mut self) {
        GrGLTextureParameters_SamplerOverriddenState_invalidate(self)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        GrGLTextureParameters_SamplerOverriddenState_SamplerOverriddenState(&mut __bindgen_tmp);
        __bindgen_tmp
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrGLTextureParameters_NonsamplerState {
    pub fSwizzleKey: u32,
    pub fBaseMipMapLevel: GrGLint,
    pub fMaxMipMapLevel: GrGLint,
}
#[test]
fn bindgen_test_layout_GrGLTextureParameters_NonsamplerState() {
    assert_eq!(
        ::core::mem::size_of::<GrGLTextureParameters_NonsamplerState>(),
        12usize,
        concat!(
            "Size of: ",
            stringify!(GrGLTextureParameters_NonsamplerState)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<GrGLTextureParameters_NonsamplerState>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(GrGLTextureParameters_NonsamplerState)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrGLTextureParameters_NonsamplerState>())).fSwizzleKey
                as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLTextureParameters_NonsamplerState),
            "::",
            stringify!(fSwizzleKey)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrGLTextureParameters_NonsamplerState>())).fBaseMipMapLevel
                as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLTextureParameters_NonsamplerState),
            "::",
            stringify!(fBaseMipMapLevel)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrGLTextureParameters_NonsamplerState>())).fMaxMipMapLevel
                as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLTextureParameters_NonsamplerState),
            "::",
            stringify!(fMaxMipMapLevel)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN21GrGLTextureParameters15NonsamplerState10invalidateEv"]
    pub fn GrGLTextureParameters_NonsamplerState_invalidate(
        this: *mut GrGLTextureParameters_NonsamplerState,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN21GrGLTextureParameters15NonsamplerStateC1Ev"]
    pub fn GrGLTextureParameters_NonsamplerState_NonsamplerState(
        this: *mut GrGLTextureParameters_NonsamplerState,
    );
}
impl GrGLTextureParameters_NonsamplerState {
    #[inline]
    pub unsafe fn invalidate(&mut self) {
        GrGLTextureParameters_NonsamplerState_invalidate(self)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        GrGLTextureParameters_NonsamplerState_NonsamplerState(&mut __bindgen_tmp);
        __bindgen_tmp
    }
}
pub const GrGLTextureParameters_kExpiredTimestamp: GrGLTextureParameters_ResetTimestamp = 0;
#[test]
fn bindgen_test_layout_GrGLTextureParameters() {
    assert_eq!(
        ::core::mem::size_of::<GrGLTextureParameters>(),
        56usize,
        concat!("Size of: ", stringify!(GrGLTextureParameters))
    );
    assert_eq!(
        ::core::mem::align_of::<GrGLTextureParameters>(),
        8usize,
        concat!("Alignment of ", stringify!(GrGLTextureParameters))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrGLTextureParameters>())).fSamplerOverriddenState as *const _
                as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLTextureParameters),
            "::",
            stringify!(fSamplerOverriddenState)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrGLTextureParameters>())).fNonsamplerState as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLTextureParameters),
            "::",
            stringify!(fNonsamplerState)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrGLTextureParameters>())).fResetTimestamp as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLTextureParameters),
            "::",
            stringify!(fResetTimestamp)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN21GrGLTextureParameters10invalidateEv"]
    pub fn GrGLTextureParameters_invalidate(this: *mut GrGLTextureParameters);
}
extern "C" {
    #[link_name = "\u{1}_ZN21GrGLTextureParameters3setEPKNS_22SamplerOverriddenStateERKNS_15NonsamplerStateEm"]
    pub fn GrGLTextureParameters_set(
        this: *mut GrGLTextureParameters,
        samplerState: *const GrGLTextureParameters_SamplerOverriddenState,
        nonsamplerState: *const GrGLTextureParameters_NonsamplerState,
        currTimestamp: GrGLTextureParameters_ResetTimestamp,
    );
}
impl GrGLTextureParameters {
    #[inline]
    pub unsafe fn invalidate(&mut self) {
        GrGLTextureParameters_invalidate(self)
    }
    #[inline]
    pub unsafe fn set(
        &mut self,
        samplerState: *const GrGLTextureParameters_SamplerOverriddenState,
        nonsamplerState: *const GrGLTextureParameters_NonsamplerState,
        currTimestamp: GrGLTextureParameters_ResetTimestamp,
    ) {
        GrGLTextureParameters_set(self, samplerState, nonsamplerState, currTimestamp)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrGLBackendTextureInfo {
    pub fInfo: GrGLTextureInfo,
    pub fParams: *mut GrGLTextureParameters,
}
#[test]
fn bindgen_test_layout_GrGLBackendTextureInfo() {
    assert_eq!(
        ::core::mem::size_of::<GrGLBackendTextureInfo>(),
        24usize,
        concat!("Size of: ", stringify!(GrGLBackendTextureInfo))
    );
    assert_eq!(
        ::core::mem::align_of::<GrGLBackendTextureInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(GrGLBackendTextureInfo))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrGLBackendTextureInfo>())).fInfo as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLBackendTextureInfo),
            "::",
            stringify!(fInfo)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrGLBackendTextureInfo>())).fParams as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLBackendTextureInfo),
            "::",
            stringify!(fParams)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN22GrGLBackendTextureInfo7cleanupEv"]
    pub fn GrGLBackendTextureInfo_cleanup(this: *mut GrGLBackendTextureInfo);
}
extern "C" {
    #[link_name = "\u{1}_ZN22GrGLBackendTextureInfo6assignERKS_b"]
    pub fn GrGLBackendTextureInfo_assign(
        this: *mut GrGLBackendTextureInfo,
        arg1: *const GrGLBackendTextureInfo,
        thisIsValid: bool,
    );
}
impl GrGLBackendTextureInfo {
    #[inline]
    pub unsafe fn cleanup(&mut self) {
        GrGLBackendTextureInfo_cleanup(self)
    }
    #[inline]
    pub unsafe fn assign(&mut self, arg1: *const GrGLBackendTextureInfo, thisIsValid: bool) {
        GrGLBackendTextureInfo_assign(self, arg1, thisIsValid)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrVkImageLayout {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrVkBackendSurfaceInfo {
    pub fImageInfo: GrVkImageInfo,
    pub fLayout: *mut GrVkImageLayout,
}
#[test]
fn bindgen_test_layout_GrVkBackendSurfaceInfo() {
    assert_eq!(
        ::core::mem::size_of::<GrVkBackendSurfaceInfo>(),
        128usize,
        concat!("Size of: ", stringify!(GrVkBackendSurfaceInfo))
    );
    assert_eq!(
        ::core::mem::align_of::<GrVkBackendSurfaceInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(GrVkBackendSurfaceInfo))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrVkBackendSurfaceInfo>())).fImageInfo as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkBackendSurfaceInfo),
            "::",
            stringify!(fImageInfo)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrVkBackendSurfaceInfo>())).fLayout as *const _ as usize },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(GrVkBackendSurfaceInfo),
            "::",
            stringify!(fLayout)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN22GrVkBackendSurfaceInfo7cleanupEv"]
    pub fn GrVkBackendSurfaceInfo_cleanup(this: *mut GrVkBackendSurfaceInfo);
}
extern "C" {
    #[link_name = "\u{1}_ZN22GrVkBackendSurfaceInfo6assignERKS_b"]
    pub fn GrVkBackendSurfaceInfo_assign(
        this: *mut GrVkBackendSurfaceInfo,
        arg1: *const GrVkBackendSurfaceInfo,
        isValid: bool,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN22GrVkBackendSurfaceInfo14setImageLayoutE13VkImageLayout"]
    pub fn GrVkBackendSurfaceInfo_setImageLayout(
        this: *mut GrVkBackendSurfaceInfo,
        layout: VkImageLayout,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK22GrVkBackendSurfaceInfo18getGrVkImageLayoutEv"]
    pub fn GrVkBackendSurfaceInfo_getGrVkImageLayout(
        this: *const GrVkBackendSurfaceInfo,
    ) -> sk_sp<GrVkImageLayout>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK22GrVkBackendSurfaceInfo13snapImageInfoEv"]
    pub fn GrVkBackendSurfaceInfo_snapImageInfo(
        this: *const GrVkBackendSurfaceInfo,
    ) -> GrVkImageInfo;
}
impl GrVkBackendSurfaceInfo {
    #[inline]
    pub unsafe fn cleanup(&mut self) {
        GrVkBackendSurfaceInfo_cleanup(self)
    }
    #[inline]
    pub unsafe fn assign(&mut self, arg1: *const GrVkBackendSurfaceInfo, isValid: bool) {
        GrVkBackendSurfaceInfo_assign(self, arg1, isValid)
    }
    #[inline]
    pub unsafe fn setImageLayout(&mut self, layout: VkImageLayout) {
        GrVkBackendSurfaceInfo_setImageLayout(self, layout)
    }
    #[inline]
    pub unsafe fn getGrVkImageLayout(&self) -> sk_sp<GrVkImageLayout> {
        GrVkBackendSurfaceInfo_getGrVkImageLayout(self)
    }
    #[inline]
    pub unsafe fn snapImageInfo(&self) -> GrVkImageInfo {
        GrVkBackendSurfaceInfo_snapImageInfo(self)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrBackendFormat {
    pub fBackend: GrBackendApi,
    pub fValid: bool,
    pub __bindgen_anon_1: GrBackendFormat__bindgen_ty_1,
    pub fTextureType: GrTextureType,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union GrBackendFormat__bindgen_ty_1 {
    pub fGLFormat: GrGLenum,
    pub fVk: GrBackendFormat__bindgen_ty_1__bindgen_ty_1,
    pub fMockColorType: GrColorType,
    _bindgen_union_align: [u64; 6usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrBackendFormat__bindgen_ty_1__bindgen_ty_1 {
    pub fFormat: VkFormat,
    pub fYcbcrConversionInfo: GrVkYcbcrConversionInfo,
}
#[test]
fn bindgen_test_layout_GrBackendFormat__bindgen_ty_1__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<GrBackendFormat__bindgen_ty_1__bindgen_ty_1>(),
        48usize,
        concat!(
            "Size of: ",
            stringify!(GrBackendFormat__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<GrBackendFormat__bindgen_ty_1__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(GrBackendFormat__bindgen_ty_1__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrBackendFormat__bindgen_ty_1__bindgen_ty_1>())).fFormat
                as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendFormat__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(fFormat)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrBackendFormat__bindgen_ty_1__bindgen_ty_1>()))
                .fYcbcrConversionInfo as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendFormat__bindgen_ty_1__bindgen_ty_1),
            "::",
            stringify!(fYcbcrConversionInfo)
        )
    );
}
#[test]
fn bindgen_test_layout_GrBackendFormat__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<GrBackendFormat__bindgen_ty_1>(),
        48usize,
        concat!("Size of: ", stringify!(GrBackendFormat__bindgen_ty_1))
    );
    assert_eq!(
        ::core::mem::align_of::<GrBackendFormat__bindgen_ty_1>(),
        8usize,
        concat!("Alignment of ", stringify!(GrBackendFormat__bindgen_ty_1))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrBackendFormat__bindgen_ty_1>())).fGLFormat as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendFormat__bindgen_ty_1),
            "::",
            stringify!(fGLFormat)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrBackendFormat__bindgen_ty_1>())).fVk as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendFormat__bindgen_ty_1),
            "::",
            stringify!(fVk)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrBackendFormat__bindgen_ty_1>())).fMockColorType as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendFormat__bindgen_ty_1),
            "::",
            stringify!(fMockColorType)
        )
    );
}
#[test]
fn bindgen_test_layout_GrBackendFormat() {
    assert_eq!(
        ::core::mem::size_of::<GrBackendFormat>(),
        64usize,
        concat!("Size of: ", stringify!(GrBackendFormat))
    );
    assert_eq!(
        ::core::mem::align_of::<GrBackendFormat>(),
        8usize,
        concat!("Alignment of ", stringify!(GrBackendFormat))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrBackendFormat>())).fBackend as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendFormat),
            "::",
            stringify!(fBackend)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrBackendFormat>())).fValid as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendFormat),
            "::",
            stringify!(fValid)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrBackendFormat>())).fTextureType as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendFormat),
            "::",
            stringify!(fTextureType)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN15GrBackendFormat6MakeVkERK23GrVkYcbcrConversionInfo"]
    pub fn GrBackendFormat_MakeVk(ycbcrInfo: *const GrVkYcbcrConversionInfo) -> GrBackendFormat;
}
extern "C" {
    #[link_name = "\u{1}_ZNK15GrBackendFormat11getGLFormatEv"]
    pub fn GrBackendFormat_getGLFormat(this: *const GrBackendFormat) -> *const GrGLenum;
}
extern "C" {
    #[link_name = "\u{1}_ZNK15GrBackendFormat11getGLTargetEv"]
    pub fn GrBackendFormat_getGLTarget(this: *const GrBackendFormat) -> *const GrGLenum;
}
extern "C" {
    #[link_name = "\u{1}_ZNK15GrBackendFormat11getVkFormatEv"]
    pub fn GrBackendFormat_getVkFormat(this: *const GrBackendFormat) -> *const VkFormat;
}
extern "C" {
    #[link_name = "\u{1}_ZNK15GrBackendFormat24getVkYcbcrConversionInfoEv"]
    pub fn GrBackendFormat_getVkYcbcrConversionInfo(
        this: *const GrBackendFormat,
    ) -> *const GrVkYcbcrConversionInfo;
}
extern "C" {
    #[link_name = "\u{1}_ZNK15GrBackendFormat16getMockColorTypeEv"]
    pub fn GrBackendFormat_getMockColorType(this: *const GrBackendFormat) -> *const GrColorType;
}
extern "C" {
    #[link_name = "\u{1}_ZNK15GrBackendFormat13makeTexture2DEv"]
    pub fn GrBackendFormat_makeTexture2D(this: *const GrBackendFormat) -> GrBackendFormat;
}
extern "C" {
    #[link_name = "\u{1}_ZN15GrBackendFormatC1ERKS_"]
    pub fn GrBackendFormat_GrBackendFormat(this: *mut GrBackendFormat, src: *const GrBackendFormat);
}
impl GrBackendFormat {
    #[inline]
    pub unsafe fn MakeVk(ycbcrInfo: *const GrVkYcbcrConversionInfo) -> GrBackendFormat {
        GrBackendFormat_MakeVk(ycbcrInfo)
    }
    #[inline]
    pub unsafe fn getGLFormat(&self) -> *const GrGLenum {
        GrBackendFormat_getGLFormat(self)
    }
    #[inline]
    pub unsafe fn getGLTarget(&self) -> *const GrGLenum {
        GrBackendFormat_getGLTarget(self)
    }
    #[inline]
    pub unsafe fn getVkFormat(&self) -> *const VkFormat {
        GrBackendFormat_getVkFormat(self)
    }
    #[inline]
    pub unsafe fn getVkYcbcrConversionInfo(&self) -> *const GrVkYcbcrConversionInfo {
        GrBackendFormat_getVkYcbcrConversionInfo(self)
    }
    #[inline]
    pub unsafe fn getMockColorType(&self) -> *const GrColorType {
        GrBackendFormat_getMockColorType(self)
    }
    #[inline]
    pub unsafe fn makeTexture2D(&self) -> GrBackendFormat {
        GrBackendFormat_makeTexture2D(self)
    }
    #[inline]
    pub unsafe fn new(src: *const GrBackendFormat) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        GrBackendFormat_GrBackendFormat(&mut __bindgen_tmp, src);
        __bindgen_tmp
    }
}
#[repr(C)]
pub struct GrBackendTexture {
    pub fIsValid: bool,
    pub fWidth: ::std::os::raw::c_int,
    pub fHeight: ::std::os::raw::c_int,
    pub fConfig: GrPixelConfig,
    pub fMipMapped: GrMipMapped,
    pub fBackend: GrBackendApi,
    pub __bindgen_anon_1: GrBackendTexture__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union GrBackendTexture__bindgen_ty_1 {
    pub fGLInfo: GrGLBackendTextureInfo,
    pub fVkInfo: GrVkBackendSurfaceInfo,
    pub fMockInfo: GrMockTextureInfo,
    _bindgen_union_align: [u64; 16usize],
}
#[test]
fn bindgen_test_layout_GrBackendTexture__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<GrBackendTexture__bindgen_ty_1>(),
        128usize,
        concat!("Size of: ", stringify!(GrBackendTexture__bindgen_ty_1))
    );
    assert_eq!(
        ::core::mem::align_of::<GrBackendTexture__bindgen_ty_1>(),
        8usize,
        concat!("Alignment of ", stringify!(GrBackendTexture__bindgen_ty_1))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrBackendTexture__bindgen_ty_1>())).fGLInfo as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendTexture__bindgen_ty_1),
            "::",
            stringify!(fGLInfo)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrBackendTexture__bindgen_ty_1>())).fVkInfo as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendTexture__bindgen_ty_1),
            "::",
            stringify!(fVkInfo)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrBackendTexture__bindgen_ty_1>())).fMockInfo as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendTexture__bindgen_ty_1),
            "::",
            stringify!(fMockInfo)
        )
    );
}
#[test]
fn bindgen_test_layout_GrBackendTexture() {
    assert_eq!(
        ::core::mem::size_of::<GrBackendTexture>(),
        152usize,
        concat!("Size of: ", stringify!(GrBackendTexture))
    );
    assert_eq!(
        ::core::mem::align_of::<GrBackendTexture>(),
        8usize,
        concat!("Alignment of ", stringify!(GrBackendTexture))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrBackendTexture>())).fIsValid as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendTexture),
            "::",
            stringify!(fIsValid)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrBackendTexture>())).fWidth as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendTexture),
            "::",
            stringify!(fWidth)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrBackendTexture>())).fHeight as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendTexture),
            "::",
            stringify!(fHeight)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrBackendTexture>())).fConfig as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendTexture),
            "::",
            stringify!(fConfig)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrBackendTexture>())).fMipMapped as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendTexture),
            "::",
            stringify!(fMipMapped)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrBackendTexture>())).fBackend as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendTexture),
            "::",
            stringify!(fBackend)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK16GrBackendTexture16getGLTextureInfoEP15GrGLTextureInfo"]
    pub fn GrBackendTexture_getGLTextureInfo(
        this: *const GrBackendTexture,
        arg1: *mut GrGLTextureInfo,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN16GrBackendTexture27glTextureParametersModifiedEv"]
    pub fn GrBackendTexture_glTextureParametersModified(this: *mut GrBackendTexture);
}
extern "C" {
    #[link_name = "\u{1}_ZNK16GrBackendTexture14getVkImageInfoEP13GrVkImageInfo"]
    pub fn GrBackendTexture_getVkImageInfo(
        this: *const GrBackendTexture,
        arg1: *mut GrVkImageInfo,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN16GrBackendTexture16setVkImageLayoutE13VkImageLayout"]
    pub fn GrBackendTexture_setVkImageLayout(this: *mut GrBackendTexture, arg1: VkImageLayout);
}
extern "C" {
    #[link_name = "\u{1}_ZNK16GrBackendTexture16getBackendFormatEv"]
    pub fn GrBackendTexture_getBackendFormat(this: *const GrBackendTexture) -> GrBackendFormat;
}
extern "C" {
    #[link_name = "\u{1}_ZNK16GrBackendTexture18getMockTextureInfoEP17GrMockTextureInfo"]
    pub fn GrBackendTexture_getMockTextureInfo(
        this: *const GrBackendTexture,
        arg1: *mut GrMockTextureInfo,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK16GrBackendTexture11isProtectedEv"]
    pub fn GrBackendTexture_isProtected(this: *const GrBackendTexture) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN16GrBackendTexture13isSameTextureERKS_"]
    pub fn GrBackendTexture_isSameTexture(
        this: *mut GrBackendTexture,
        arg1: *const GrBackendTexture,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN16GrBackendTextureC1Eii11GrMipMappedRK15GrGLTextureInfo"]
    pub fn GrBackendTexture_GrBackendTexture(
        this: *mut GrBackendTexture,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        arg1: GrMipMapped,
        glInfo: *const GrGLTextureInfo,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN16GrBackendTextureC1EiiRK13GrVkImageInfo"]
    pub fn GrBackendTexture_GrBackendTexture1(
        this: *mut GrBackendTexture,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        vkInfo: *const GrVkImageInfo,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN16GrBackendTextureC1Eii11GrMipMappedRK17GrMockTextureInfo"]
    pub fn GrBackendTexture_GrBackendTexture2(
        this: *mut GrBackendTexture,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        arg1: GrMipMapped,
        mockInfo: *const GrMockTextureInfo,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN16GrBackendTextureC1ERKS_"]
    pub fn GrBackendTexture_GrBackendTexture3(
        this: *mut GrBackendTexture,
        that: *const GrBackendTexture,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN16GrBackendTextureD1Ev"]
    pub fn GrBackendTexture_GrBackendTexture_destructor(this: *mut GrBackendTexture);
}
impl GrBackendTexture {
    #[inline]
    pub unsafe fn getGLTextureInfo(&self, arg1: *mut GrGLTextureInfo) -> bool {
        GrBackendTexture_getGLTextureInfo(self, arg1)
    }
    #[inline]
    pub unsafe fn glTextureParametersModified(&mut self) {
        GrBackendTexture_glTextureParametersModified(self)
    }
    #[inline]
    pub unsafe fn getVkImageInfo(&self, arg1: *mut GrVkImageInfo) -> bool {
        GrBackendTexture_getVkImageInfo(self, arg1)
    }
    #[inline]
    pub unsafe fn setVkImageLayout(&mut self, arg1: VkImageLayout) {
        GrBackendTexture_setVkImageLayout(self, arg1)
    }
    #[inline]
    pub unsafe fn getBackendFormat(&self) -> GrBackendFormat {
        GrBackendTexture_getBackendFormat(self)
    }
    #[inline]
    pub unsafe fn getMockTextureInfo(&self, arg1: *mut GrMockTextureInfo) -> bool {
        GrBackendTexture_getMockTextureInfo(self, arg1)
    }
    #[inline]
    pub unsafe fn isProtected(&self) -> bool {
        GrBackendTexture_isProtected(self)
    }
    #[inline]
    pub unsafe fn isSameTexture(&mut self, arg1: *const GrBackendTexture) -> bool {
        GrBackendTexture_isSameTexture(self, arg1)
    }
    #[inline]
    pub unsafe fn new(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        arg1: GrMipMapped,
        glInfo: *const GrGLTextureInfo,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        GrBackendTexture_GrBackendTexture(&mut __bindgen_tmp, width, height, arg1, glInfo);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        vkInfo: *const GrVkImageInfo,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        GrBackendTexture_GrBackendTexture1(&mut __bindgen_tmp, width, height, vkInfo);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new2(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        arg1: GrMipMapped,
        mockInfo: *const GrMockTextureInfo,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        GrBackendTexture_GrBackendTexture2(&mut __bindgen_tmp, width, height, arg1, mockInfo);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new3(that: *const GrBackendTexture) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        GrBackendTexture_GrBackendTexture3(&mut __bindgen_tmp, that);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        GrBackendTexture_GrBackendTexture_destructor(self)
    }
}
#[repr(C)]
pub struct GrBackendRenderTarget {
    pub fIsValid: bool,
    pub fWidth: ::std::os::raw::c_int,
    pub fHeight: ::std::os::raw::c_int,
    pub fSampleCnt: ::std::os::raw::c_int,
    pub fStencilBits: ::std::os::raw::c_int,
    pub fConfig: GrPixelConfig,
    pub fBackend: GrBackendApi,
    pub __bindgen_anon_1: GrBackendRenderTarget__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union GrBackendRenderTarget__bindgen_ty_1 {
    pub fGLInfo: GrGLFramebufferInfo,
    pub fVkInfo: GrVkBackendSurfaceInfo,
    pub fMockInfo: GrMockRenderTargetInfo,
    _bindgen_union_align: [u64; 16usize],
}
#[test]
fn bindgen_test_layout_GrBackendRenderTarget__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<GrBackendRenderTarget__bindgen_ty_1>(),
        128usize,
        concat!("Size of: ", stringify!(GrBackendRenderTarget__bindgen_ty_1))
    );
    assert_eq!(
        ::core::mem::align_of::<GrBackendRenderTarget__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(GrBackendRenderTarget__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrBackendRenderTarget__bindgen_ty_1>())).fGLInfo as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendRenderTarget__bindgen_ty_1),
            "::",
            stringify!(fGLInfo)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrBackendRenderTarget__bindgen_ty_1>())).fVkInfo as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendRenderTarget__bindgen_ty_1),
            "::",
            stringify!(fVkInfo)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrBackendRenderTarget__bindgen_ty_1>())).fMockInfo as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendRenderTarget__bindgen_ty_1),
            "::",
            stringify!(fMockInfo)
        )
    );
}
#[test]
fn bindgen_test_layout_GrBackendRenderTarget() {
    assert_eq!(
        ::core::mem::size_of::<GrBackendRenderTarget>(),
        160usize,
        concat!("Size of: ", stringify!(GrBackendRenderTarget))
    );
    assert_eq!(
        ::core::mem::align_of::<GrBackendRenderTarget>(),
        8usize,
        concat!("Alignment of ", stringify!(GrBackendRenderTarget))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrBackendRenderTarget>())).fIsValid as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendRenderTarget),
            "::",
            stringify!(fIsValid)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrBackendRenderTarget>())).fWidth as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendRenderTarget),
            "::",
            stringify!(fWidth)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrBackendRenderTarget>())).fHeight as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendRenderTarget),
            "::",
            stringify!(fHeight)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrBackendRenderTarget>())).fSampleCnt as *const _ as usize
        },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendRenderTarget),
            "::",
            stringify!(fSampleCnt)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrBackendRenderTarget>())).fStencilBits as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendRenderTarget),
            "::",
            stringify!(fStencilBits)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrBackendRenderTarget>())).fConfig as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendRenderTarget),
            "::",
            stringify!(fConfig)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrBackendRenderTarget>())).fBackend as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendRenderTarget),
            "::",
            stringify!(fBackend)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK21GrBackendRenderTarget20getGLFramebufferInfoEP19GrGLFramebufferInfo"]
    pub fn GrBackendRenderTarget_getGLFramebufferInfo(
        this: *const GrBackendRenderTarget,
        arg1: *mut GrGLFramebufferInfo,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK21GrBackendRenderTarget14getVkImageInfoEP13GrVkImageInfo"]
    pub fn GrBackendRenderTarget_getVkImageInfo(
        this: *const GrBackendRenderTarget,
        arg1: *mut GrVkImageInfo,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN21GrBackendRenderTarget16setVkImageLayoutE13VkImageLayout"]
    pub fn GrBackendRenderTarget_setVkImageLayout(
        this: *mut GrBackendRenderTarget,
        arg1: VkImageLayout,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK21GrBackendRenderTarget16getBackendFormatEv"]
    pub fn GrBackendRenderTarget_getBackendFormat(
        this: *const GrBackendRenderTarget,
    ) -> GrBackendFormat;
}
extern "C" {
    #[link_name = "\u{1}_ZNK21GrBackendRenderTarget23getMockRenderTargetInfoEP22GrMockRenderTargetInfo"]
    pub fn GrBackendRenderTarget_getMockRenderTargetInfo(
        this: *const GrBackendRenderTarget,
        arg1: *mut GrMockRenderTargetInfo,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK21GrBackendRenderTarget11isProtectedEv"]
    pub fn GrBackendRenderTarget_isProtected(this: *const GrBackendRenderTarget) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN21GrBackendRenderTargetC1EiiiiRK19GrGLFramebufferInfo"]
    pub fn GrBackendRenderTarget_GrBackendRenderTarget(
        this: *mut GrBackendRenderTarget,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        sampleCnt: ::std::os::raw::c_int,
        stencilBits: ::std::os::raw::c_int,
        glInfo: *const GrGLFramebufferInfo,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN21GrBackendRenderTargetC1EiiiiRK13GrVkImageInfo"]
    pub fn GrBackendRenderTarget_GrBackendRenderTarget1(
        this: *mut GrBackendRenderTarget,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        sampleCnt: ::std::os::raw::c_int,
        stencilBits: ::std::os::raw::c_int,
        vkInfo: *const GrVkImageInfo,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN21GrBackendRenderTargetC1EiiiRK13GrVkImageInfo"]
    pub fn GrBackendRenderTarget_GrBackendRenderTarget2(
        this: *mut GrBackendRenderTarget,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        sampleCnt: ::std::os::raw::c_int,
        vkInfo: *const GrVkImageInfo,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN21GrBackendRenderTargetC1EiiiiRK22GrMockRenderTargetInfo"]
    pub fn GrBackendRenderTarget_GrBackendRenderTarget3(
        this: *mut GrBackendRenderTarget,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        sampleCnt: ::std::os::raw::c_int,
        stencilBits: ::std::os::raw::c_int,
        mockInfo: *const GrMockRenderTargetInfo,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN21GrBackendRenderTargetC1ERKS_"]
    pub fn GrBackendRenderTarget_GrBackendRenderTarget4(
        this: *mut GrBackendRenderTarget,
        that: *const GrBackendRenderTarget,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN21GrBackendRenderTargetD1Ev"]
    pub fn GrBackendRenderTarget_GrBackendRenderTarget_destructor(this: *mut GrBackendRenderTarget);
}
impl GrBackendRenderTarget {
    #[inline]
    pub unsafe fn getGLFramebufferInfo(&self, arg1: *mut GrGLFramebufferInfo) -> bool {
        GrBackendRenderTarget_getGLFramebufferInfo(self, arg1)
    }
    #[inline]
    pub unsafe fn getVkImageInfo(&self, arg1: *mut GrVkImageInfo) -> bool {
        GrBackendRenderTarget_getVkImageInfo(self, arg1)
    }
    #[inline]
    pub unsafe fn setVkImageLayout(&mut self, arg1: VkImageLayout) {
        GrBackendRenderTarget_setVkImageLayout(self, arg1)
    }
    #[inline]
    pub unsafe fn getBackendFormat(&self) -> GrBackendFormat {
        GrBackendRenderTarget_getBackendFormat(self)
    }
    #[inline]
    pub unsafe fn getMockRenderTargetInfo(&self, arg1: *mut GrMockRenderTargetInfo) -> bool {
        GrBackendRenderTarget_getMockRenderTargetInfo(self, arg1)
    }
    #[inline]
    pub unsafe fn isProtected(&self) -> bool {
        GrBackendRenderTarget_isProtected(self)
    }
    #[inline]
    pub unsafe fn new(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        sampleCnt: ::std::os::raw::c_int,
        stencilBits: ::std::os::raw::c_int,
        glInfo: *const GrGLFramebufferInfo,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        GrBackendRenderTarget_GrBackendRenderTarget(
            &mut __bindgen_tmp,
            width,
            height,
            sampleCnt,
            stencilBits,
            glInfo,
        );
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        sampleCnt: ::std::os::raw::c_int,
        stencilBits: ::std::os::raw::c_int,
        vkInfo: *const GrVkImageInfo,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        GrBackendRenderTarget_GrBackendRenderTarget1(
            &mut __bindgen_tmp,
            width,
            height,
            sampleCnt,
            stencilBits,
            vkInfo,
        );
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new2(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        sampleCnt: ::std::os::raw::c_int,
        vkInfo: *const GrVkImageInfo,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        GrBackendRenderTarget_GrBackendRenderTarget2(
            &mut __bindgen_tmp,
            width,
            height,
            sampleCnt,
            vkInfo,
        );
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new3(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        sampleCnt: ::std::os::raw::c_int,
        stencilBits: ::std::os::raw::c_int,
        mockInfo: *const GrMockRenderTargetInfo,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        GrBackendRenderTarget_GrBackendRenderTarget3(
            &mut __bindgen_tmp,
            width,
            height,
            sampleCnt,
            stencilBits,
            mockInfo,
        );
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new4(that: *const GrBackendRenderTarget) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        GrBackendRenderTarget_GrBackendRenderTarget4(&mut __bindgen_tmp, that);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        GrBackendRenderTarget_GrBackendRenderTarget_destructor(self)
    }
}
#[repr(C)]
pub struct SkPathEffect {
    pub _base: SkFlattenable,
}
#[repr(C)]
pub struct SkPathEffect_PointData {
    pub fFlags: u32,
    pub fPoints: *mut SkPoint,
    pub fNumPoints: ::std::os::raw::c_int,
    pub fSize: SkVector,
    pub fClipRect: SkRect,
    pub fPath: SkPath,
    pub fFirst: SkPath,
    pub fLast: SkPath,
}
pub const SkPathEffect_PointData_PointFlags_kCircles_PointFlag: SkPathEffect_PointData_PointFlags =
    1;
pub const SkPathEffect_PointData_PointFlags_kUsePath_PointFlag: SkPathEffect_PointData_PointFlags =
    2;
pub const SkPathEffect_PointData_PointFlags_kUseClip_PointFlag: SkPathEffect_PointData_PointFlags =
    4;
pub type SkPathEffect_PointData_PointFlags = u32;
#[test]
fn bindgen_test_layout_SkPathEffect_PointData() {
    assert_eq!(
        ::core::mem::size_of::<SkPathEffect_PointData>(),
        96usize,
        concat!("Size of: ", stringify!(SkPathEffect_PointData))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPathEffect_PointData>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPathEffect_PointData))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathEffect_PointData>())).fFlags as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathEffect_PointData),
            "::",
            stringify!(fFlags)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathEffect_PointData>())).fPoints as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathEffect_PointData),
            "::",
            stringify!(fPoints)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkPathEffect_PointData>())).fNumPoints as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathEffect_PointData),
            "::",
            stringify!(fNumPoints)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathEffect_PointData>())).fSize as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathEffect_PointData),
            "::",
            stringify!(fSize)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkPathEffect_PointData>())).fClipRect as *const _ as usize
        },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathEffect_PointData),
            "::",
            stringify!(fClipRect)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathEffect_PointData>())).fPath as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathEffect_PointData),
            "::",
            stringify!(fPath)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathEffect_PointData>())).fFirst as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathEffect_PointData),
            "::",
            stringify!(fFirst)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathEffect_PointData>())).fLast as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathEffect_PointData),
            "::",
            stringify!(fLast)
        )
    );
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkPathEffect_DashType {
    kNone_DashType = 0,
    kDash_DashType = 1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkPathEffect_DashInfo {
    pub fIntervals: *mut SkScalar,
    pub fCount: i32,
    pub fPhase: SkScalar,
}
#[test]
fn bindgen_test_layout_SkPathEffect_DashInfo() {
    assert_eq!(
        ::core::mem::size_of::<SkPathEffect_DashInfo>(),
        16usize,
        concat!("Size of: ", stringify!(SkPathEffect_DashInfo))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPathEffect_DashInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPathEffect_DashInfo))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkPathEffect_DashInfo>())).fIntervals as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathEffect_DashInfo),
            "::",
            stringify!(fIntervals)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathEffect_DashInfo>())).fCount as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathEffect_DashInfo),
            "::",
            stringify!(fCount)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathEffect_DashInfo>())).fPhase as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathEffect_DashInfo),
            "::",
            stringify!(fPhase)
        )
    );
}
pub type SkPathEffect_INHERITED = SkFlattenable;
#[test]
fn bindgen_test_layout_SkPathEffect() {
    assert_eq!(
        ::core::mem::size_of::<SkPathEffect>(),
        16usize,
        concat!("Size of: ", stringify!(SkPathEffect))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPathEffect>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPathEffect))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN12SkPathEffect7MakeSumE5sk_spIS_ES1_"]
    pub fn SkPathEffect_MakeSum(
        first: sk_sp<SkPathEffect>,
        second: sk_sp<SkPathEffect>,
    ) -> sk_sp<SkPathEffect>;
}
extern "C" {
    #[link_name = "\u{1}_ZN12SkPathEffect11MakeComposeE5sk_spIS_ES1_"]
    pub fn SkPathEffect_MakeCompose(
        outer: sk_sp<SkPathEffect>,
        inner: sk_sp<SkPathEffect>,
    ) -> sk_sp<SkPathEffect>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkPathEffect10filterPathEP6SkPathRKS0_P11SkStrokeRecPK6SkRect"]
    pub fn SkPathEffect_filterPath(
        this: *const SkPathEffect,
        dst: *mut SkPath,
        src: *const SkPath,
        arg1: *mut SkStrokeRec,
        cullR: *const SkRect,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkPathEffect17computeFastBoundsEP6SkRectRKS0_"]
    pub fn SkPathEffect_computeFastBounds(
        this: *const SkPathEffect,
        dst: *mut SkRect,
        src: *const SkRect,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkPathEffect8asPointsEPNS_9PointDataERK6SkPathRK11SkStrokeRecRK8SkMatrixPK6SkRect"]
    pub fn SkPathEffect_asPoints(
        this: *const SkPathEffect,
        results: *mut SkPathEffect_PointData,
        src: *const SkPath,
        arg1: *const SkStrokeRec,
        arg2: *const SkMatrix,
        cullR: *const SkRect,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkPathEffect7asADashEPNS_8DashInfoE"]
    pub fn SkPathEffect_asADash(
        this: *const SkPathEffect,
        info: *mut SkPathEffect_DashInfo,
    ) -> SkPathEffect_DashType;
}
extern "C" {
    #[link_name = "\u{1}_ZN12SkPathEffect20RegisterFlattenablesEv"]
    pub fn SkPathEffect_RegisterFlattenables();
}
impl SkPathEffect {
    #[inline]
    pub unsafe fn MakeSum(
        first: sk_sp<SkPathEffect>,
        second: sk_sp<SkPathEffect>,
    ) -> sk_sp<SkPathEffect> {
        SkPathEffect_MakeSum(first, second)
    }
    #[inline]
    pub unsafe fn MakeCompose(
        outer: sk_sp<SkPathEffect>,
        inner: sk_sp<SkPathEffect>,
    ) -> sk_sp<SkPathEffect> {
        SkPathEffect_MakeCompose(outer, inner)
    }
    #[inline]
    pub unsafe fn filterPath(
        &self,
        dst: *mut SkPath,
        src: *const SkPath,
        arg1: *mut SkStrokeRec,
        cullR: *const SkRect,
    ) -> bool {
        SkPathEffect_filterPath(self, dst, src, arg1, cullR)
    }
    #[inline]
    pub unsafe fn computeFastBounds(&self, dst: *mut SkRect, src: *const SkRect) {
        SkPathEffect_computeFastBounds(self, dst, src)
    }
    #[inline]
    pub unsafe fn asPoints(
        &self,
        results: *mut SkPathEffect_PointData,
        src: *const SkPath,
        arg1: *const SkStrokeRec,
        arg2: *const SkMatrix,
        cullR: *const SkRect,
    ) -> bool {
        SkPathEffect_asPoints(self, results, src, arg1, arg2, cullR)
    }
    #[inline]
    pub unsafe fn asADash(&self, info: *mut SkPathEffect_DashInfo) -> SkPathEffect_DashType {
        SkPathEffect_asADash(self, info)
    }
    #[inline]
    pub unsafe fn RegisterFlattenables() {
        SkPathEffect_RegisterFlattenables()
    }
}
#[repr(C)]
pub struct GrDriverBugWorkarounds {
    pub add_and_true_to_loop_condition: bool,
    pub disable_blend_equation_advanced: bool,
    pub disable_discard_framebuffer: bool,
    pub disable_texture_storage: bool,
    pub disallow_large_instanced_draw: bool,
    pub emulate_abs_int_function: bool,
    pub flush_on_framebuffer_change: bool,
    pub gl_clear_broken: bool,
    pub max_fragment_uniform_vectors_32: bool,
    pub max_msaa_sample_count_4: bool,
    pub max_texture_size_limit_4096: bool,
    pub pack_parameters_workaround_with_pack_buffer: bool,
    pub remove_pow_with_constant_exponent: bool,
    pub restore_scissor_on_fbo_change: bool,
    pub rewrite_do_while_loops: bool,
    pub unbind_attachments_on_bound_render_fbo_delete: bool,
    pub unfold_short_circuit_as_ternary_operation: bool,
}
#[test]
fn bindgen_test_layout_GrDriverBugWorkarounds() {
    assert_eq!(
        ::core::mem::size_of::<GrDriverBugWorkarounds>(),
        17usize,
        concat!("Size of: ", stringify!(GrDriverBugWorkarounds))
    );
    assert_eq!(
        ::core::mem::align_of::<GrDriverBugWorkarounds>(),
        1usize,
        concat!("Alignment of ", stringify!(GrDriverBugWorkarounds))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrDriverBugWorkarounds>())).add_and_true_to_loop_condition
                as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrDriverBugWorkarounds),
            "::",
            stringify!(add_and_true_to_loop_condition)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrDriverBugWorkarounds>())).disable_blend_equation_advanced
                as *const _ as usize
        },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(GrDriverBugWorkarounds),
            "::",
            stringify!(disable_blend_equation_advanced)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrDriverBugWorkarounds>())).disable_discard_framebuffer
                as *const _ as usize
        },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(GrDriverBugWorkarounds),
            "::",
            stringify!(disable_discard_framebuffer)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrDriverBugWorkarounds>())).disable_texture_storage as *const _
                as usize
        },
        3usize,
        concat!(
            "Offset of field: ",
            stringify!(GrDriverBugWorkarounds),
            "::",
            stringify!(disable_texture_storage)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrDriverBugWorkarounds>())).disallow_large_instanced_draw
                as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(GrDriverBugWorkarounds),
            "::",
            stringify!(disallow_large_instanced_draw)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrDriverBugWorkarounds>())).emulate_abs_int_function as *const _
                as usize
        },
        5usize,
        concat!(
            "Offset of field: ",
            stringify!(GrDriverBugWorkarounds),
            "::",
            stringify!(emulate_abs_int_function)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrDriverBugWorkarounds>())).flush_on_framebuffer_change
                as *const _ as usize
        },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(GrDriverBugWorkarounds),
            "::",
            stringify!(flush_on_framebuffer_change)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrDriverBugWorkarounds>())).gl_clear_broken as *const _ as usize
        },
        7usize,
        concat!(
            "Offset of field: ",
            stringify!(GrDriverBugWorkarounds),
            "::",
            stringify!(gl_clear_broken)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrDriverBugWorkarounds>())).max_fragment_uniform_vectors_32
                as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(GrDriverBugWorkarounds),
            "::",
            stringify!(max_fragment_uniform_vectors_32)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrDriverBugWorkarounds>())).max_msaa_sample_count_4 as *const _
                as usize
        },
        9usize,
        concat!(
            "Offset of field: ",
            stringify!(GrDriverBugWorkarounds),
            "::",
            stringify!(max_msaa_sample_count_4)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrDriverBugWorkarounds>())).max_texture_size_limit_4096
                as *const _ as usize
        },
        10usize,
        concat!(
            "Offset of field: ",
            stringify!(GrDriverBugWorkarounds),
            "::",
            stringify!(max_texture_size_limit_4096)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrDriverBugWorkarounds>()))
                .pack_parameters_workaround_with_pack_buffer as *const _ as usize
        },
        11usize,
        concat!(
            "Offset of field: ",
            stringify!(GrDriverBugWorkarounds),
            "::",
            stringify!(pack_parameters_workaround_with_pack_buffer)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrDriverBugWorkarounds>())).remove_pow_with_constant_exponent
                as *const _ as usize
        },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(GrDriverBugWorkarounds),
            "::",
            stringify!(remove_pow_with_constant_exponent)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrDriverBugWorkarounds>())).restore_scissor_on_fbo_change
                as *const _ as usize
        },
        13usize,
        concat!(
            "Offset of field: ",
            stringify!(GrDriverBugWorkarounds),
            "::",
            stringify!(restore_scissor_on_fbo_change)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrDriverBugWorkarounds>())).rewrite_do_while_loops as *const _
                as usize
        },
        14usize,
        concat!(
            "Offset of field: ",
            stringify!(GrDriverBugWorkarounds),
            "::",
            stringify!(rewrite_do_while_loops)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrDriverBugWorkarounds>()))
                .unbind_attachments_on_bound_render_fbo_delete as *const _ as usize
        },
        15usize,
        concat!(
            "Offset of field: ",
            stringify!(GrDriverBugWorkarounds),
            "::",
            stringify!(unbind_attachments_on_bound_render_fbo_delete)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrDriverBugWorkarounds>()))
                .unfold_short_circuit_as_ternary_operation as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(GrDriverBugWorkarounds),
            "::",
            stringify!(unfold_short_circuit_as_ternary_operation)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN22GrDriverBugWorkarounds14applyOverridesERKS_"]
    pub fn GrDriverBugWorkarounds_applyOverrides(
        this: *mut GrDriverBugWorkarounds,
        workarounds: *const GrDriverBugWorkarounds,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN22GrDriverBugWorkaroundsC1Ev"]
    pub fn GrDriverBugWorkarounds_GrDriverBugWorkarounds(this: *mut GrDriverBugWorkarounds);
}
extern "C" {
    #[link_name = "\u{1}_ZN22GrDriverBugWorkaroundsC1ERKSt6vectorIiSaIiEE"]
    pub fn GrDriverBugWorkarounds_GrDriverBugWorkarounds1(
        this: *mut GrDriverBugWorkarounds,
        workarounds: *const u8,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN22GrDriverBugWorkaroundsD1Ev"]
    pub fn GrDriverBugWorkarounds_GrDriverBugWorkarounds_destructor(
        this: *mut GrDriverBugWorkarounds,
    );
}
impl GrDriverBugWorkarounds {
    #[inline]
    pub unsafe fn applyOverrides(&mut self, workarounds: *const GrDriverBugWorkarounds) {
        GrDriverBugWorkarounds_applyOverrides(self, workarounds)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        GrDriverBugWorkarounds_GrDriverBugWorkarounds(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(workarounds: *const u8) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        GrDriverBugWorkarounds_GrDriverBugWorkarounds1(&mut __bindgen_tmp, workarounds);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        GrDriverBugWorkarounds_GrDriverBugWorkarounds_destructor(self)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkExecutor {
    _unused: [u8; 0],
}
#[repr(C)]
pub struct GrContextOptions {
    pub fSuppressPrints: bool,
    pub fMaxTextureSizeOverride: ::std::os::raw::c_int,
    pub fBufferMapThreshold: ::std::os::raw::c_int,
    pub fExecutor: *mut SkExecutor,
    pub fDoManualMipmapping: bool,
    pub fDisableCoverageCountingPaths: bool,
    pub fDisableDistanceFieldPaths: bool,
    pub fAllowPathMaskCaching: bool,
    pub fDisableGpuYUVConversion: bool,
    pub fGlyphCacheTextureMaximumBytes: usize,
    pub fMinDistanceFieldFontSize: f32,
    pub fGlyphsAsPathsFontSize: f32,
    pub fAllowMultipleGlyphCacheTextures: GrContextOptions_Enable,
    pub fAvoidStencilBuffers: bool,
    pub fSharpenMipmappedTextures: bool,
    pub fUseDrawInsteadOfClear: GrContextOptions_Enable,
    pub fReduceOpListSplitting: GrContextOptions_Enable,
    pub fPreferExternalImagesOverES3: bool,
    pub fDisableDriverCorrectnessWorkarounds: bool,
    pub fPersistentCache: *mut GrContextOptions_PersistentCache,
    pub fDisallowGLSLBinaryCaching: bool,
    pub fShaderErrorHandler: *mut GrContextOptions_ShaderErrorHandler,
    pub fInternalMultisampleCount: ::std::os::raw::c_int,
    pub fDriverBugWorkarounds: GrDriverBugWorkarounds,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum GrContextOptions_Enable {
    kNo = 0,
    kYes = 1,
    kDefault = 2,
}
#[repr(C)]
pub struct GrContextOptions_PersistentCache__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
pub struct GrContextOptions_PersistentCache {
    pub vtable_: *const GrContextOptions_PersistentCache__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_GrContextOptions_PersistentCache() {
    assert_eq!(
        ::core::mem::size_of::<GrContextOptions_PersistentCache>(),
        8usize,
        concat!("Size of: ", stringify!(GrContextOptions_PersistentCache))
    );
    assert_eq!(
        ::core::mem::align_of::<GrContextOptions_PersistentCache>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(GrContextOptions_PersistentCache)
        )
    );
}
#[repr(C)]
pub struct GrContextOptions_ShaderErrorHandler__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
pub struct GrContextOptions_ShaderErrorHandler {
    pub vtable_: *const GrContextOptions_ShaderErrorHandler__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_GrContextOptions_ShaderErrorHandler() {
    assert_eq!(
        ::core::mem::size_of::<GrContextOptions_ShaderErrorHandler>(),
        8usize,
        concat!("Size of: ", stringify!(GrContextOptions_ShaderErrorHandler))
    );
    assert_eq!(
        ::core::mem::align_of::<GrContextOptions_ShaderErrorHandler>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(GrContextOptions_ShaderErrorHandler)
        )
    );
}
#[test]
fn bindgen_test_layout_GrContextOptions() {
    assert_eq!(
        ::core::mem::size_of::<GrContextOptions>(),
        120usize,
        concat!("Size of: ", stringify!(GrContextOptions))
    );
    assert_eq!(
        ::core::mem::align_of::<GrContextOptions>(),
        8usize,
        concat!("Alignment of ", stringify!(GrContextOptions))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fSuppressPrints as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fSuppressPrints)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fMaxTextureSizeOverride as *const _
                as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fMaxTextureSizeOverride)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fBufferMapThreshold as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fBufferMapThreshold)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrContextOptions>())).fExecutor as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fExecutor)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fDoManualMipmapping as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fDoManualMipmapping)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fDisableCoverageCountingPaths as *const _
                as usize
        },
        25usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fDisableCoverageCountingPaths)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fDisableDistanceFieldPaths as *const _
                as usize
        },
        26usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fDisableDistanceFieldPaths)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fAllowPathMaskCaching as *const _ as usize
        },
        27usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fAllowPathMaskCaching)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fDisableGpuYUVConversion as *const _
                as usize
        },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fDisableGpuYUVConversion)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fGlyphCacheTextureMaximumBytes as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fGlyphCacheTextureMaximumBytes)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fMinDistanceFieldFontSize as *const _
                as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fMinDistanceFieldFontSize)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fGlyphsAsPathsFontSize as *const _
                as usize
        },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fGlyphsAsPathsFontSize)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fAllowMultipleGlyphCacheTextures
                as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fAllowMultipleGlyphCacheTextures)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fAvoidStencilBuffers as *const _ as usize
        },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fAvoidStencilBuffers)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fSharpenMipmappedTextures as *const _
                as usize
        },
        53usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fSharpenMipmappedTextures)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fUseDrawInsteadOfClear as *const _
                as usize
        },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fUseDrawInsteadOfClear)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fReduceOpListSplitting as *const _
                as usize
        },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fReduceOpListSplitting)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fPreferExternalImagesOverES3 as *const _
                as usize
        },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fPreferExternalImagesOverES3)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fDisableDriverCorrectnessWorkarounds
                as *const _ as usize
        },
        65usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fDisableDriverCorrectnessWorkarounds)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fPersistentCache as *const _ as usize
        },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fPersistentCache)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fDisallowGLSLBinaryCaching as *const _
                as usize
        },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fDisallowGLSLBinaryCaching)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fShaderErrorHandler as *const _ as usize
        },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fShaderErrorHandler)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fInternalMultisampleCount as *const _
                as usize
        },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fInternalMultisampleCount)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrContextOptions>())).fDriverBugWorkarounds as *const _ as usize
        },
        100usize,
        concat!(
            "Offset of field: ",
            stringify!(GrContextOptions),
            "::",
            stringify!(fDriverBugWorkarounds)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrBaseContextPriv {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrSkSLFPFactoryCache {
    _unused: [u8; 0],
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub struct GrContext_Base {
    pub _bindgen_opaque_blob: [u64; 20usize],
}
pub type GrContext_Base_INHERITED = SkRefCnt;
#[test]
fn bindgen_test_layout_GrContext_Base() {
    assert_eq!(
        ::core::mem::size_of::<GrContext_Base>(),
        160usize,
        concat!("Size of: ", stringify!(GrContext_Base))
    );
    assert_eq!(
        ::core::mem::align_of::<GrContext_Base>(),
        8usize,
        concat!("Alignment of ", stringify!(GrContext_Base))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN14GrContext_Base4privEv"]
    pub fn GrContext_Base_priv(this: *mut GrContext_Base) -> GrBaseContextPriv;
}
extern "C" {
    #[link_name = "\u{1}_ZNK14GrContext_Base4privEv"]
    pub fn GrContext_Base_priv1(this: *const GrContext_Base) -> GrBaseContextPriv;
}
extern "C" {
    #[link_name = "\u{1}_ZNK14GrContext_Base4capsEv"]
    pub fn GrContext_Base_caps(this: *const GrContext_Base) -> *const GrCaps;
}
extern "C" {
    #[link_name = "\u{1}_ZNK14GrContext_Base7refCapsEv"]
    pub fn GrContext_Base_refCaps(this: *const GrContext_Base) -> sk_sp<GrCaps>;
}
extern "C" {
    #[link_name = "\u{1}_ZN14GrContext_Base14fpFactoryCacheEv"]
    pub fn GrContext_Base_fpFactoryCache(this: *mut GrContext_Base) -> sk_sp<GrSkSLFPFactoryCache>;
}
extern "C" {
    #[link_name = "\u{1}_ZN14GrContext_BaseC1E12GrBackendApiRK16GrContextOptionsj"]
    pub fn GrContext_Base_GrContext_Base(
        this: *mut GrContext_Base,
        backend: GrBackendApi,
        options: *const GrContextOptions,
        contextID: u32,
    );
}
impl GrContext_Base {
    #[inline]
    pub unsafe fn priv_(&mut self) -> GrBaseContextPriv {
        GrContext_Base_priv(self)
    }
    #[inline]
    pub unsafe fn priv1(&self) -> GrBaseContextPriv {
        GrContext_Base_priv1(self)
    }
    #[inline]
    pub unsafe fn caps(&self) -> *const GrCaps {
        GrContext_Base_caps(self)
    }
    #[inline]
    pub unsafe fn refCaps(&self) -> sk_sp<GrCaps> {
        GrContext_Base_refCaps(self)
    }
    #[inline]
    pub unsafe fn fpFactoryCache(&mut self) -> sk_sp<GrSkSLFPFactoryCache> {
        GrContext_Base_fpFactoryCache(self)
    }
    #[inline]
    pub unsafe fn new(
        backend: GrBackendApi,
        options: *const GrContextOptions,
        contextID: u32,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        GrContext_Base_GrContext_Base(&mut __bindgen_tmp, backend, options, contextID);
        __bindgen_tmp
    }
}
extern "C" {
    #[link_name = "\u{1}_ZN14GrContext_BaseD1Ev"]
    pub fn GrContext_Base_GrContext_Base_destructor(this: *mut GrContext_Base);
}
extern "C" {
    #[link_name = "\u{1}_ZN14GrContext_Base4initE5sk_spIK6GrCapsES0_I20GrSkSLFPFactoryCacheE"]
    pub fn GrContext_Base_init(
        this: *mut ::std::os::raw::c_void,
        arg1: sk_sp<GrCaps>,
        arg2: sk_sp<GrSkSLFPFactoryCache>,
    ) -> bool;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrImageContextPriv {
    _unused: [u8; 0],
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub struct GrImageContext {
    pub _bindgen_opaque_blob: [u64; 22usize],
}
pub type GrImageContext_INHERITED = GrContext_Base;
#[test]
fn bindgen_test_layout_GrImageContext() {
    assert_eq!(
        ::core::mem::size_of::<GrImageContext>(),
        176usize,
        concat!("Size of: ", stringify!(GrImageContext))
    );
    assert_eq!(
        ::core::mem::align_of::<GrImageContext>(),
        8usize,
        concat!("Alignment of ", stringify!(GrImageContext))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN14GrImageContext4privEv"]
    pub fn GrImageContext_priv(this: *mut GrImageContext) -> GrImageContextPriv;
}
extern "C" {
    #[link_name = "\u{1}_ZNK14GrImageContext4privEv"]
    pub fn GrImageContext_priv1(this: *const GrImageContext) -> GrImageContextPriv;
}
extern "C" {
    #[link_name = "\u{1}_ZNK14GrImageContext9abandonedEv"]
    pub fn GrImageContext_abandoned(this: *const GrImageContext) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN14GrImageContextC1E12GrBackendApiRK16GrContextOptionsj"]
    pub fn GrImageContext_GrImageContext(
        this: *mut GrImageContext,
        arg1: GrBackendApi,
        arg2: *const GrContextOptions,
        contextID: u32,
    );
}
impl GrImageContext {
    #[inline]
    pub unsafe fn priv_(&mut self) -> GrImageContextPriv {
        GrImageContext_priv(self)
    }
    #[inline]
    pub unsafe fn priv1(&self) -> GrImageContextPriv {
        GrImageContext_priv1(self)
    }
    #[inline]
    pub unsafe fn abandoned(&self) -> bool {
        GrImageContext_abandoned(self)
    }
    #[inline]
    pub unsafe fn new(arg1: GrBackendApi, arg2: *const GrContextOptions, contextID: u32) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        GrImageContext_GrImageContext(&mut __bindgen_tmp, arg1, arg2, contextID);
        __bindgen_tmp
    }
}
extern "C" {
    #[link_name = "\u{1}_ZN14GrImageContextD1Ev"]
    pub fn GrImageContext_GrImageContext_destructor(this: *mut GrImageContext);
}
extern "C" {
    #[link_name = "\u{1}_ZN14GrImageContext14abandonContextEv"]
    pub fn GrImageContext_abandonContext(this: *mut ::std::os::raw::c_void);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrDrawingManager {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrOnFlushCallbackObject {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrOpMemoryPool {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrRecordingContextPriv {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrSurfaceContext {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrSurfaceProxy {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrTextBlobCache {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrTextureContext {
    _unused: [u8; 0],
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub struct GrRecordingContext {
    pub _bindgen_opaque_blob: [u64; 27usize],
}
pub type GrRecordingContext_INHERITED = GrImageContext;
#[test]
fn bindgen_test_layout_GrRecordingContext() {
    assert_eq!(
        ::core::mem::size_of::<GrRecordingContext>(),
        216usize,
        concat!("Size of: ", stringify!(GrRecordingContext))
    );
    assert_eq!(
        ::core::mem::align_of::<GrRecordingContext>(),
        8usize,
        concat!("Alignment of ", stringify!(GrRecordingContext))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN18GrRecordingContext4privEv"]
    pub fn GrRecordingContext_priv(this: *mut GrRecordingContext) -> GrRecordingContextPriv;
}
extern "C" {
    #[link_name = "\u{1}_ZNK18GrRecordingContext4privEv"]
    pub fn GrRecordingContext_priv1(this: *const GrRecordingContext) -> GrRecordingContextPriv;
}
extern "C" {
    #[link_name = "\u{1}_ZN18GrRecordingContext19setupDrawingManagerEbb"]
    pub fn GrRecordingContext_setupDrawingManager(
        this: *mut GrRecordingContext,
        sortOpLists: bool,
        reduceOpListSplitting: bool,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN18GrRecordingContext14drawingManagerEv"]
    pub fn GrRecordingContext_drawingManager(
        this: *mut GrRecordingContext,
    ) -> *mut GrDrawingManager;
}
extern "C" {
    #[link_name = "\u{1}_ZN18GrRecordingContext15refOpMemoryPoolEv"]
    pub fn GrRecordingContext_refOpMemoryPool(
        this: *mut GrRecordingContext,
    ) -> sk_sp<GrOpMemoryPool>;
}
extern "C" {
    #[link_name = "\u{1}_ZN18GrRecordingContext12opMemoryPoolEv"]
    pub fn GrRecordingContext_opMemoryPool(this: *mut GrRecordingContext) -> *mut GrOpMemoryPool;
}
extern "C" {
    #[link_name = "\u{1}_ZN18GrRecordingContext16getTextBlobCacheEv"]
    pub fn GrRecordingContext_getTextBlobCache(
        this: *mut GrRecordingContext,
    ) -> *mut GrTextBlobCache;
}
extern "C" {
    #[link_name = "\u{1}_ZNK18GrRecordingContext16getTextBlobCacheEv"]
    pub fn GrRecordingContext_getTextBlobCache1(
        this: *const GrRecordingContext,
    ) -> *const GrTextBlobCache;
}
extern "C" {
    #[link_name = "\u{1}_ZN18GrRecordingContext24addOnFlushCallbackObjectEP23GrOnFlushCallbackObject"]
    pub fn GrRecordingContext_addOnFlushCallbackObject(
        this: *mut GrRecordingContext,
        arg1: *mut GrOnFlushCallbackObject,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN18GrRecordingContext25makeWrappedSurfaceContextE5sk_spI14GrSurfaceProxyE11GrColorType11SkAlphaTypeS0_I12SkColorSpaceEPK14SkSurfaceProps"]
    pub fn GrRecordingContext_makeWrappedSurfaceContext(
        this: *mut GrRecordingContext,
        arg1: sk_sp<GrSurfaceProxy>,
        arg2: GrColorType,
        arg3: SkAlphaType,
        arg4: sk_sp<SkColorSpace>,
        arg5: *const SkSurfaceProps,
    ) -> sk_sp<GrSurfaceContext>;
}
extern "C" {
    #[link_name = "\u{1}_ZN18GrRecordingContext26makeDeferredTextureContextE12SkBackingFitii11GrColorType11SkAlphaType5sk_spI12SkColorSpaceE11GrMipMapped15GrSurfaceOrigin10SkBudgeted11GrProtected"]
    pub fn GrRecordingContext_makeDeferredTextureContext(
        this: *mut GrRecordingContext,
        arg1: SkBackingFit,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        arg2: GrColorType,
        arg3: SkAlphaType,
        arg4: sk_sp<SkColorSpace>,
        arg5: GrMipMapped,
        arg6: GrSurfaceOrigin,
        arg7: SkBudgeted,
        arg8: GrProtected,
    ) -> sk_sp<GrTextureContext>;
}
extern "C" {
    #[link_name = "\u{1}_ZN18GrRecordingContext31makeDeferredRenderTargetContextE12SkBackingFitii11GrColorType5sk_spI12SkColorSpaceEi11GrMipMapped15GrSurfaceOriginPK14SkSurfaceProps10SkBudgeted11GrProtected"]
    pub fn GrRecordingContext_makeDeferredRenderTargetContext(
        this: *mut GrRecordingContext,
        fit: SkBackingFit,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        colorType: GrColorType,
        colorSpace: sk_sp<SkColorSpace>,
        sampleCnt: ::std::os::raw::c_int,
        arg1: GrMipMapped,
        origin: GrSurfaceOrigin,
        surfaceProps: *const SkSurfaceProps,
        arg2: SkBudgeted,
        isProtected: GrProtected,
    ) -> sk_sp<GrRenderTargetContext>;
}
extern "C" {
    #[link_name = "\u{1}_ZN18GrRecordingContext43makeDeferredRenderTargetContextWithFallbackE12SkBackingFitii11GrColorType5sk_spI12SkColorSpaceEi11GrMipMapped15GrSurfaceOriginPK14SkSurfaceProps10SkBudgeted11GrProtected"]
    pub fn GrRecordingContext_makeDeferredRenderTargetContextWithFallback(
        this: *mut GrRecordingContext,
        fit: SkBackingFit,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        colorType: GrColorType,
        colorSpace: sk_sp<SkColorSpace>,
        sampleCnt: ::std::os::raw::c_int,
        arg1: GrMipMapped,
        origin: GrSurfaceOrigin,
        surfaceProps: *const SkSurfaceProps,
        budgeted: SkBudgeted,
        isProtected: GrProtected,
    ) -> sk_sp<GrRenderTargetContext>;
}
extern "C" {
    #[link_name = "\u{1}_ZN18GrRecordingContextC1E12GrBackendApiRK16GrContextOptionsj"]
    pub fn GrRecordingContext_GrRecordingContext(
        this: *mut GrRecordingContext,
        arg1: GrBackendApi,
        arg2: *const GrContextOptions,
        contextID: u32,
    );
}
impl GrRecordingContext {
    #[inline]
    pub unsafe fn priv_(&mut self) -> GrRecordingContextPriv {
        GrRecordingContext_priv(self)
    }
    #[inline]
    pub unsafe fn priv1(&self) -> GrRecordingContextPriv {
        GrRecordingContext_priv1(self)
    }
    #[inline]
    pub unsafe fn setupDrawingManager(&mut self, sortOpLists: bool, reduceOpListSplitting: bool) {
        GrRecordingContext_setupDrawingManager(self, sortOpLists, reduceOpListSplitting)
    }
    #[inline]
    pub unsafe fn drawingManager(&mut self) -> *mut GrDrawingManager {
        GrRecordingContext_drawingManager(self)
    }
    #[inline]
    pub unsafe fn refOpMemoryPool(&mut self) -> sk_sp<GrOpMemoryPool> {
        GrRecordingContext_refOpMemoryPool(self)
    }
    #[inline]
    pub unsafe fn opMemoryPool(&mut self) -> *mut GrOpMemoryPool {
        GrRecordingContext_opMemoryPool(self)
    }
    #[inline]
    pub unsafe fn getTextBlobCache(&mut self) -> *mut GrTextBlobCache {
        GrRecordingContext_getTextBlobCache(self)
    }
    #[inline]
    pub unsafe fn getTextBlobCache1(&self) -> *const GrTextBlobCache {
        GrRecordingContext_getTextBlobCache1(self)
    }
    #[inline]
    pub unsafe fn addOnFlushCallbackObject(&mut self, arg1: *mut GrOnFlushCallbackObject) {
        GrRecordingContext_addOnFlushCallbackObject(self, arg1)
    }
    #[inline]
    pub unsafe fn makeWrappedSurfaceContext(
        &mut self,
        arg1: sk_sp<GrSurfaceProxy>,
        arg2: GrColorType,
        arg3: SkAlphaType,
        arg4: sk_sp<SkColorSpace>,
        arg5: *const SkSurfaceProps,
    ) -> sk_sp<GrSurfaceContext> {
        GrRecordingContext_makeWrappedSurfaceContext(self, arg1, arg2, arg3, arg4, arg5)
    }
    #[inline]
    pub unsafe fn makeDeferredTextureContext(
        &mut self,
        arg1: SkBackingFit,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        arg2: GrColorType,
        arg3: SkAlphaType,
        arg4: sk_sp<SkColorSpace>,
        arg5: GrMipMapped,
        arg6: GrSurfaceOrigin,
        arg7: SkBudgeted,
        arg8: GrProtected,
    ) -> sk_sp<GrTextureContext> {
        GrRecordingContext_makeDeferredTextureContext(
            self, arg1, width, height, arg2, arg3, arg4, arg5, arg6, arg7, arg8,
        )
    }
    #[inline]
    pub unsafe fn makeDeferredRenderTargetContext(
        &mut self,
        fit: SkBackingFit,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        colorType: GrColorType,
        colorSpace: sk_sp<SkColorSpace>,
        sampleCnt: ::std::os::raw::c_int,
        arg1: GrMipMapped,
        origin: GrSurfaceOrigin,
        surfaceProps: *const SkSurfaceProps,
        arg2: SkBudgeted,
        isProtected: GrProtected,
    ) -> sk_sp<GrRenderTargetContext> {
        GrRecordingContext_makeDeferredRenderTargetContext(
            self,
            fit,
            width,
            height,
            colorType,
            colorSpace,
            sampleCnt,
            arg1,
            origin,
            surfaceProps,
            arg2,
            isProtected,
        )
    }
    #[inline]
    pub unsafe fn makeDeferredRenderTargetContextWithFallback(
        &mut self,
        fit: SkBackingFit,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        colorType: GrColorType,
        colorSpace: sk_sp<SkColorSpace>,
        sampleCnt: ::std::os::raw::c_int,
        arg1: GrMipMapped,
        origin: GrSurfaceOrigin,
        surfaceProps: *const SkSurfaceProps,
        budgeted: SkBudgeted,
        isProtected: GrProtected,
    ) -> sk_sp<GrRenderTargetContext> {
        GrRecordingContext_makeDeferredRenderTargetContextWithFallback(
            self,
            fit,
            width,
            height,
            colorType,
            colorSpace,
            sampleCnt,
            arg1,
            origin,
            surfaceProps,
            budgeted,
            isProtected,
        )
    }
    #[inline]
    pub unsafe fn new(arg1: GrBackendApi, arg2: *const GrContextOptions, contextID: u32) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        GrRecordingContext_GrRecordingContext(&mut __bindgen_tmp, arg1, arg2, contextID);
        __bindgen_tmp
    }
}
extern "C" {
    #[link_name = "\u{1}_ZN18GrRecordingContextD1Ev"]
    pub fn GrRecordingContext_GrRecordingContext_destructor(this: *mut GrRecordingContext);
}
extern "C" {
    #[link_name = "\u{1}_ZN18GrRecordingContext4initE5sk_spIK6GrCapsES0_I20GrSkSLFPFactoryCacheE"]
    pub fn GrRecordingContext_init(
        this: *mut ::std::os::raw::c_void,
        arg1: sk_sp<GrCaps>,
        arg2: sk_sp<GrSkSLFPFactoryCache>,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN18GrRecordingContext14abandonContextEv"]
    pub fn GrRecordingContext_abandonContext(this: *mut ::std::os::raw::c_void);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrAtlasManager {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrContextPriv {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrTextureProxy {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrVkBackendContext {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkTraceMemoryDump {
    _unused: [u8; 0],
}
#[repr(C)]
#[repr(align(8))]
pub struct GrContext {
    pub _bindgen_opaque_blob: [u64; 35usize],
}
pub type GrContext_INHERITED = GrRecordingContext;
#[test]
fn bindgen_test_layout_GrContext() {
    assert_eq!(
        ::core::mem::size_of::<GrContext>(),
        280usize,
        concat!("Size of: ", stringify!(GrContext))
    );
    assert_eq!(
        ::core::mem::align_of::<GrContext>(),
        8usize,
        concat!("Alignment of ", stringify!(GrContext))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext6MakeGLE5sk_spIK13GrGLInterfaceERK16GrContextOptions"]
    pub fn GrContext_MakeGL(
        arg1: sk_sp<GrGLInterface>,
        arg2: *const GrContextOptions,
    ) -> sk_sp<GrContext>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext6MakeGLE5sk_spIK13GrGLInterfaceE"]
    pub fn GrContext_MakeGL1(arg1: sk_sp<GrGLInterface>) -> sk_sp<GrContext>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext6MakeGLERK16GrContextOptions"]
    pub fn GrContext_MakeGL2(arg1: *const GrContextOptions) -> sk_sp<GrContext>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext6MakeGLEv"]
    pub fn GrContext_MakeGL3() -> sk_sp<GrContext>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext10MakeVulkanERK18GrVkBackendContextRK16GrContextOptions"]
    pub fn GrContext_MakeVulkan(
        arg1: *const GrVkBackendContext,
        arg2: *const GrContextOptions,
    ) -> sk_sp<GrContext>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext10MakeVulkanERK18GrVkBackendContext"]
    pub fn GrContext_MakeVulkan1(arg1: *const GrVkBackendContext) -> sk_sp<GrContext>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext8MakeMockEPK13GrMockOptionsRK16GrContextOptions"]
    pub fn GrContext_MakeMock(
        arg1: *const GrMockOptions,
        arg2: *const GrContextOptions,
    ) -> sk_sp<GrContext>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext8MakeMockEPK13GrMockOptions"]
    pub fn GrContext_MakeMock1(arg1: *const GrMockOptions) -> sk_sp<GrContext>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext15threadSafeProxyEv"]
    pub fn GrContext_threadSafeProxy(this: *mut GrContext) -> sk_sp<GrContextThreadSafeProxy>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext12resetContextEj"]
    pub fn GrContext_resetContext(this: *mut GrContext, state: u32);
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext22resetGLTextureBindingsEv"]
    pub fn GrContext_resetGLTextureBindings(this: *mut GrContext);
}
extern "C" {
    #[link_name = "\u{1}_ZNK9GrContext22getResourceCacheLimitsEPiPm"]
    pub fn GrContext_getResourceCacheLimits(
        this: *const GrContext,
        maxResources: *mut ::std::os::raw::c_int,
        maxResourceBytes: *mut usize,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK9GrContext21getResourceCacheUsageEPiPm"]
    pub fn GrContext_getResourceCacheUsage(
        this: *const GrContext,
        resourceCount: *mut ::std::os::raw::c_int,
        resourceBytes: *mut usize,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK9GrContext30getResourceCachePurgeableBytesEv"]
    pub fn GrContext_getResourceCachePurgeableBytes(this: *const GrContext) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext22setResourceCacheLimitsEim"]
    pub fn GrContext_setResourceCacheLimits(
        this: *mut GrContext,
        maxResources: ::std::os::raw::c_int,
        maxResourceBytes: usize,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext22performDeferredCleanupENSt6chrono8durationIlSt5ratioILl1ELl1000EEEE"]
    pub fn GrContext_performDeferredCleanup(
        this: *mut GrContext,
        msNotUsed: std_chrono_milliseconds,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext22purgeUnlockedResourcesEmb"]
    pub fn GrContext_purgeUnlockedResources(
        this: *mut GrContext,
        bytesToPurge: usize,
        preferScratchResources: bool,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext22purgeUnlockedResourcesEb"]
    pub fn GrContext_purgeUnlockedResources1(this: *mut GrContext, scratchResourcesOnly: bool);
}
extern "C" {
    #[link_name = "\u{1}_ZNK9GrContext14maxTextureSizeEv"]
    pub fn GrContext_maxTextureSize(this: *const GrContext) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9GrContext19maxRenderTargetSizeEv"]
    pub fn GrContext_maxRenderTargetSize(this: *const GrContext) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9GrContext25colorTypeSupportedAsImageE11SkColorType"]
    pub fn GrContext_colorTypeSupportedAsImage(this: *const GrContext, arg1: SkColorType) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9GrContext33maxSurfaceSampleCountForColorTypeE11SkColorType"]
    pub fn GrContext_maxSurfaceSampleCountForColorType(
        this: *const GrContext,
        arg1: SkColorType,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext4waitEiPK18GrBackendSemaphore"]
    pub fn GrContext_wait(
        this: *mut GrContext,
        numSemaphores: ::std::os::raw::c_int,
        waitSemaphores: *const GrBackendSemaphore,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext5flushERK11GrFlushInfoRK30GrPrepareForExternalIORequests"]
    pub fn GrContext_flush(
        this: *mut GrContext,
        arg1: *const GrFlushInfo,
        arg2: *const GrPrepareForExternalIORequests,
    ) -> GrSemaphoresSubmitted;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext24checkAsyncWorkCompletionEv"]
    pub fn GrContext_checkAsyncWorkCompletion(this: *mut GrContext);
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext4privEv"]
    pub fn GrContext_priv(this: *mut GrContext) -> GrContextPriv;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9GrContext4privEv"]
    pub fn GrContext_priv1(this: *const GrContext) -> GrContextPriv;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9GrContext20dumpMemoryStatisticsEP17SkTraceMemoryDump"]
    pub fn GrContext_dumpMemoryStatistics(
        this: *const GrContext,
        traceMemoryDump: *mut SkTraceMemoryDump,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK9GrContext25supportsDistanceFieldTextEv"]
    pub fn GrContext_supportsDistanceFieldText(this: *const GrContext) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext24storeVkPipelineCacheDataEv"]
    pub fn GrContext_storeVkPipelineCacheData(this: *mut GrContext);
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext18ComputeTextureSizeE11SkColorTypeii11GrMipMappedb"]
    pub fn GrContext_ComputeTextureSize(
        type_: SkColorType,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        arg1: GrMipMapped,
        useNextPow2: bool,
    ) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext20createBackendTextureEiiRK15GrBackendFormat11GrMipMapped12GrRenderable11GrProtected"]
    pub fn GrContext_createBackendTexture(
        this: *mut GrContext,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        arg1: *const GrBackendFormat,
        arg2: GrMipMapped,
        arg3: GrRenderable,
        arg4: GrProtected,
    ) -> GrBackendTexture;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext20createBackendTextureEii11SkColorType11GrMipMapped12GrRenderable11GrProtected"]
    pub fn GrContext_createBackendTexture1(
        this: *mut GrContext,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        arg1: SkColorType,
        arg2: GrMipMapped,
        arg3: GrRenderable,
        arg4: GrProtected,
    ) -> GrBackendTexture;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext20createBackendTextureERK25SkSurfaceCharacterization"]
    pub fn GrContext_createBackendTexture2(
        this: *mut GrContext,
        characterization: *const SkSurfaceCharacterization,
    ) -> GrBackendTexture;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext20createBackendTextureEiiRK15GrBackendFormatRK8SkRGBA4fIL11SkAlphaType3EE11GrMipMapped12GrRenderable11GrProtected"]
    pub fn GrContext_createBackendTexture3(
        this: *mut GrContext,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        arg1: *const GrBackendFormat,
        color: *const SkColor4f,
        arg2: GrMipMapped,
        arg3: GrRenderable,
        arg4: GrProtected,
    ) -> GrBackendTexture;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext20createBackendTextureEii11SkColorTypeRK8SkRGBA4fIL11SkAlphaType3EE11GrMipMapped12GrRenderable11GrProtected"]
    pub fn GrContext_createBackendTexture4(
        this: *mut GrContext,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        arg1: SkColorType,
        color: *const SkColor4f,
        arg2: GrMipMapped,
        arg3: GrRenderable,
        arg4: GrProtected,
    ) -> GrBackendTexture;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext20createBackendTextureERK25SkSurfaceCharacterizationRK8SkRGBA4fIL11SkAlphaType3EE"]
    pub fn GrContext_createBackendTexture5(
        this: *mut GrContext,
        characterization: *const SkSurfaceCharacterization,
        color: *const SkColor4f,
    ) -> GrBackendTexture;
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext20deleteBackendTextureE16GrBackendTexture"]
    pub fn GrContext_deleteBackendTexture(this: *mut GrContext, arg1: GrBackendTexture);
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContextC2E12GrBackendApiRK16GrContextOptionsi"]
    pub fn GrContext_GrContext(
        this: *mut GrContext,
        arg1: GrBackendApi,
        arg2: *const GrContextOptions,
        contextID: i32,
    );
}
impl GrContext {
    #[inline]
    pub unsafe fn MakeGL(
        arg1: sk_sp<GrGLInterface>,
        arg2: *const GrContextOptions,
    ) -> sk_sp<GrContext> {
        GrContext_MakeGL(arg1, arg2)
    }
    #[inline]
    pub unsafe fn MakeGL1(arg1: sk_sp<GrGLInterface>) -> sk_sp<GrContext> {
        GrContext_MakeGL1(arg1)
    }
    #[inline]
    pub unsafe fn MakeGL2(arg1: *const GrContextOptions) -> sk_sp<GrContext> {
        GrContext_MakeGL2(arg1)
    }
    #[inline]
    pub unsafe fn MakeGL3() -> sk_sp<GrContext> {
        GrContext_MakeGL3()
    }
    #[inline]
    pub unsafe fn MakeVulkan(
        arg1: *const GrVkBackendContext,
        arg2: *const GrContextOptions,
    ) -> sk_sp<GrContext> {
        GrContext_MakeVulkan(arg1, arg2)
    }
    #[inline]
    pub unsafe fn MakeVulkan1(arg1: *const GrVkBackendContext) -> sk_sp<GrContext> {
        GrContext_MakeVulkan1(arg1)
    }
    #[inline]
    pub unsafe fn MakeMock(
        arg1: *const GrMockOptions,
        arg2: *const GrContextOptions,
    ) -> sk_sp<GrContext> {
        GrContext_MakeMock(arg1, arg2)
    }
    #[inline]
    pub unsafe fn MakeMock1(arg1: *const GrMockOptions) -> sk_sp<GrContext> {
        GrContext_MakeMock1(arg1)
    }
    #[inline]
    pub unsafe fn threadSafeProxy(&mut self) -> sk_sp<GrContextThreadSafeProxy> {
        GrContext_threadSafeProxy(self)
    }
    #[inline]
    pub unsafe fn resetContext(&mut self, state: u32) {
        GrContext_resetContext(self, state)
    }
    #[inline]
    pub unsafe fn resetGLTextureBindings(&mut self) {
        GrContext_resetGLTextureBindings(self)
    }
    #[inline]
    pub unsafe fn getResourceCacheLimits(
        &self,
        maxResources: *mut ::std::os::raw::c_int,
        maxResourceBytes: *mut usize,
    ) {
        GrContext_getResourceCacheLimits(self, maxResources, maxResourceBytes)
    }
    #[inline]
    pub unsafe fn getResourceCacheUsage(
        &self,
        resourceCount: *mut ::std::os::raw::c_int,
        resourceBytes: *mut usize,
    ) {
        GrContext_getResourceCacheUsage(self, resourceCount, resourceBytes)
    }
    #[inline]
    pub unsafe fn getResourceCachePurgeableBytes(&self) -> usize {
        GrContext_getResourceCachePurgeableBytes(self)
    }
    #[inline]
    pub unsafe fn setResourceCacheLimits(
        &mut self,
        maxResources: ::std::os::raw::c_int,
        maxResourceBytes: usize,
    ) {
        GrContext_setResourceCacheLimits(self, maxResources, maxResourceBytes)
    }
    #[inline]
    pub unsafe fn performDeferredCleanup(&mut self, msNotUsed: std_chrono_milliseconds) {
        GrContext_performDeferredCleanup(self, msNotUsed)
    }
    #[inline]
    pub unsafe fn purgeUnlockedResources(
        &mut self,
        bytesToPurge: usize,
        preferScratchResources: bool,
    ) {
        GrContext_purgeUnlockedResources(self, bytesToPurge, preferScratchResources)
    }
    #[inline]
    pub unsafe fn purgeUnlockedResources1(&mut self, scratchResourcesOnly: bool) {
        GrContext_purgeUnlockedResources1(self, scratchResourcesOnly)
    }
    #[inline]
    pub unsafe fn maxTextureSize(&self) -> ::std::os::raw::c_int {
        GrContext_maxTextureSize(self)
    }
    #[inline]
    pub unsafe fn maxRenderTargetSize(&self) -> ::std::os::raw::c_int {
        GrContext_maxRenderTargetSize(self)
    }
    #[inline]
    pub unsafe fn colorTypeSupportedAsImage(&self, arg1: SkColorType) -> bool {
        GrContext_colorTypeSupportedAsImage(self, arg1)
    }
    #[inline]
    pub unsafe fn maxSurfaceSampleCountForColorType(
        &self,
        arg1: SkColorType,
    ) -> ::std::os::raw::c_int {
        GrContext_maxSurfaceSampleCountForColorType(self, arg1)
    }
    #[inline]
    pub unsafe fn wait(
        &mut self,
        numSemaphores: ::std::os::raw::c_int,
        waitSemaphores: *const GrBackendSemaphore,
    ) -> bool {
        GrContext_wait(self, numSemaphores, waitSemaphores)
    }
    #[inline]
    pub unsafe fn flush(
        &mut self,
        arg1: *const GrFlushInfo,
        arg2: *const GrPrepareForExternalIORequests,
    ) -> GrSemaphoresSubmitted {
        GrContext_flush(self, arg1, arg2)
    }
    #[inline]
    pub unsafe fn checkAsyncWorkCompletion(&mut self) {
        GrContext_checkAsyncWorkCompletion(self)
    }
    #[inline]
    pub unsafe fn priv_(&mut self) -> GrContextPriv {
        GrContext_priv(self)
    }
    #[inline]
    pub unsafe fn priv1(&self) -> GrContextPriv {
        GrContext_priv1(self)
    }
    #[inline]
    pub unsafe fn dumpMemoryStatistics(&self, traceMemoryDump: *mut SkTraceMemoryDump) {
        GrContext_dumpMemoryStatistics(self, traceMemoryDump)
    }
    #[inline]
    pub unsafe fn supportsDistanceFieldText(&self) -> bool {
        GrContext_supportsDistanceFieldText(self)
    }
    #[inline]
    pub unsafe fn storeVkPipelineCacheData(&mut self) {
        GrContext_storeVkPipelineCacheData(self)
    }
    #[inline]
    pub unsafe fn ComputeTextureSize(
        type_: SkColorType,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        arg1: GrMipMapped,
        useNextPow2: bool,
    ) -> usize {
        GrContext_ComputeTextureSize(type_, width, height, arg1, useNextPow2)
    }
    #[inline]
    pub unsafe fn createBackendTexture(
        &mut self,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        arg1: *const GrBackendFormat,
        arg2: GrMipMapped,
        arg3: GrRenderable,
        arg4: GrProtected,
    ) -> GrBackendTexture {
        GrContext_createBackendTexture(self, width, height, arg1, arg2, arg3, arg4)
    }
    #[inline]
    pub unsafe fn createBackendTexture1(
        &mut self,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        arg1: SkColorType,
        arg2: GrMipMapped,
        arg3: GrRenderable,
        arg4: GrProtected,
    ) -> GrBackendTexture {
        GrContext_createBackendTexture1(self, width, height, arg1, arg2, arg3, arg4)
    }
    #[inline]
    pub unsafe fn createBackendTexture2(
        &mut self,
        characterization: *const SkSurfaceCharacterization,
    ) -> GrBackendTexture {
        GrContext_createBackendTexture2(self, characterization)
    }
    #[inline]
    pub unsafe fn createBackendTexture3(
        &mut self,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        arg1: *const GrBackendFormat,
        color: *const SkColor4f,
        arg2: GrMipMapped,
        arg3: GrRenderable,
        arg4: GrProtected,
    ) -> GrBackendTexture {
        GrContext_createBackendTexture3(self, width, height, arg1, color, arg2, arg3, arg4)
    }
    #[inline]
    pub unsafe fn createBackendTexture4(
        &mut self,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        arg1: SkColorType,
        color: *const SkColor4f,
        arg2: GrMipMapped,
        arg3: GrRenderable,
        arg4: GrProtected,
    ) -> GrBackendTexture {
        GrContext_createBackendTexture4(self, width, height, arg1, color, arg2, arg3, arg4)
    }
    #[inline]
    pub unsafe fn createBackendTexture5(
        &mut self,
        characterization: *const SkSurfaceCharacterization,
        color: *const SkColor4f,
    ) -> GrBackendTexture {
        GrContext_createBackendTexture5(self, characterization, color)
    }
    #[inline]
    pub unsafe fn deleteBackendTexture(&mut self, arg1: GrBackendTexture) {
        GrContext_deleteBackendTexture(self, arg1)
    }
    #[inline]
    pub unsafe fn new(arg1: GrBackendApi, arg2: *const GrContextOptions, contextID: i32) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        GrContext_GrContext(&mut __bindgen_tmp, arg1, arg2, contextID);
        __bindgen_tmp
    }
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContextD1Ev"]
    pub fn GrContext_GrContext_destructor(this: *mut GrContext);
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext14abandonContextEv"]
    pub fn GrContext_abandonContext(this: *mut ::std::os::raw::c_void);
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext33releaseResourcesAndAbandonContextEv"]
    pub fn GrContext_releaseResourcesAndAbandonContext(this: *mut ::std::os::raw::c_void);
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext16freeGpuResourcesEv"]
    pub fn GrContext_freeGpuResources(this: *mut ::std::os::raw::c_void);
}
extern "C" {
    #[link_name = "\u{1}_ZN9GrContext4initE5sk_spIK6GrCapsES0_I20GrSkSLFPFactoryCacheE"]
    pub fn GrContext_init(
        this: *mut ::std::os::raw::c_void,
        arg1: sk_sp<GrCaps>,
        arg2: sk_sp<GrSkSLFPFactoryCache>,
    ) -> bool;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrContextThreadSafeProxyPriv {
    _unused: [u8; 0],
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub struct GrContextThreadSafeProxy {
    pub _bindgen_opaque_blob: [u64; 20usize],
}
pub type GrContextThreadSafeProxy_INHERITED = GrContext_Base;
#[test]
fn bindgen_test_layout_GrContextThreadSafeProxy() {
    assert_eq!(
        ::core::mem::size_of::<GrContextThreadSafeProxy>(),
        160usize,
        concat!("Size of: ", stringify!(GrContextThreadSafeProxy))
    );
    assert_eq!(
        ::core::mem::align_of::<GrContextThreadSafeProxy>(),
        8usize,
        concat!("Alignment of ", stringify!(GrContextThreadSafeProxy))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN24GrContextThreadSafeProxy22createCharacterizationEmRK11SkImageInfoRK15GrBackendFormati15GrSurfaceOriginRK14SkSurfacePropsbbb11GrProtected"]
    pub fn GrContextThreadSafeProxy_createCharacterization(
        this: *mut GrContextThreadSafeProxy,
        cacheMaxResourceBytes: usize,
        ii: *const SkImageInfo,
        backendFormat: *const GrBackendFormat,
        sampleCount: ::std::os::raw::c_int,
        origin: GrSurfaceOrigin,
        surfaceProps: *const SkSurfaceProps,
        isMipMapped: bool,
        willUseGLFBO0: bool,
        isTextureable: bool,
        isProtected: GrProtected,
    ) -> SkSurfaceCharacterization;
}
extern "C" {
    #[link_name = "\u{1}_ZN24GrContextThreadSafeProxy4privEv"]
    pub fn GrContextThreadSafeProxy_priv(
        this: *mut GrContextThreadSafeProxy,
    ) -> GrContextThreadSafeProxyPriv;
}
extern "C" {
    #[link_name = "\u{1}_ZNK24GrContextThreadSafeProxy4privEv"]
    pub fn GrContextThreadSafeProxy_priv1(
        this: *const GrContextThreadSafeProxy,
    ) -> GrContextThreadSafeProxyPriv;
}
impl GrContextThreadSafeProxy {
    #[inline]
    pub unsafe fn createCharacterization(
        &mut self,
        cacheMaxResourceBytes: usize,
        ii: *const SkImageInfo,
        backendFormat: *const GrBackendFormat,
        sampleCount: ::std::os::raw::c_int,
        origin: GrSurfaceOrigin,
        surfaceProps: *const SkSurfaceProps,
        isMipMapped: bool,
        willUseGLFBO0: bool,
        isTextureable: bool,
        isProtected: GrProtected,
    ) -> SkSurfaceCharacterization {
        GrContextThreadSafeProxy_createCharacterization(
            self,
            cacheMaxResourceBytes,
            ii,
            backendFormat,
            sampleCount,
            origin,
            surfaceProps,
            isMipMapped,
            willUseGLFBO0,
            isTextureable,
            isProtected,
        )
    }
    #[inline]
    pub unsafe fn priv_(&mut self) -> GrContextThreadSafeProxyPriv {
        GrContextThreadSafeProxy_priv(self)
    }
    #[inline]
    pub unsafe fn priv1(&self) -> GrContextThreadSafeProxyPriv {
        GrContextThreadSafeProxy_priv1(self)
    }
}
extern "C" {
    #[link_name = "\u{1}_ZN24GrContextThreadSafeProxyD1Ev"]
    pub fn GrContextThreadSafeProxy_GrContextThreadSafeProxy_destructor(
        this: *mut GrContextThreadSafeProxy,
    );
}
#[repr(C)]
pub struct SkSurfaceCharacterization {
    pub fContextInfo: sk_sp<GrContextThreadSafeProxy>,
    pub fCacheMaxResourceBytes: usize,
    pub fImageInfo: SkImageInfo,
    pub fBackendFormat: GrBackendFormat,
    pub fOrigin: GrSurfaceOrigin,
    pub fSampleCnt: ::std::os::raw::c_int,
    pub fIsTextureable: SkSurfaceCharacterization_Textureable,
    pub fIsMipMapped: SkSurfaceCharacterization_MipMapped,
    pub fUsesGLFBO0: SkSurfaceCharacterization_UsesGLFBO0,
    pub fVulkanSecondaryCBCompatible: SkSurfaceCharacterization_VulkanSecondaryCBCompatible,
    pub fIsProtected: GrProtected,
    pub fSurfaceProps: SkSurfaceProps,
}
#[repr(u8)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkSurfaceCharacterization_Textureable {
    kNo = 0,
    kYes = 1,
}
#[repr(u8)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkSurfaceCharacterization_MipMapped {
    kNo = 0,
    kYes = 1,
}
#[repr(u8)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkSurfaceCharacterization_UsesGLFBO0 {
    kNo = 0,
    kYes = 1,
}
#[repr(u8)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkSurfaceCharacterization_VulkanSecondaryCBCompatible {
    kNo = 0,
    kYes = 1,
}
#[test]
fn bindgen_test_layout_SkSurfaceCharacterization() {
    assert_eq!(
        ::core::mem::size_of::<SkSurfaceCharacterization>(),
        128usize,
        concat!("Size of: ", stringify!(SkSurfaceCharacterization))
    );
    assert_eq!(
        ::core::mem::align_of::<SkSurfaceCharacterization>(),
        8usize,
        concat!("Alignment of ", stringify!(SkSurfaceCharacterization))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkSurfaceCharacterization>())).fContextInfo as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkSurfaceCharacterization),
            "::",
            stringify!(fContextInfo)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkSurfaceCharacterization>())).fCacheMaxResourceBytes
                as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkSurfaceCharacterization),
            "::",
            stringify!(fCacheMaxResourceBytes)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkSurfaceCharacterization>())).fImageInfo as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkSurfaceCharacterization),
            "::",
            stringify!(fImageInfo)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkSurfaceCharacterization>())).fBackendFormat as *const _
                as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(SkSurfaceCharacterization),
            "::",
            stringify!(fBackendFormat)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkSurfaceCharacterization>())).fOrigin as *const _ as usize
        },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(SkSurfaceCharacterization),
            "::",
            stringify!(fOrigin)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkSurfaceCharacterization>())).fSampleCnt as *const _ as usize
        },
        108usize,
        concat!(
            "Offset of field: ",
            stringify!(SkSurfaceCharacterization),
            "::",
            stringify!(fSampleCnt)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkSurfaceCharacterization>())).fIsTextureable as *const _
                as usize
        },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(SkSurfaceCharacterization),
            "::",
            stringify!(fIsTextureable)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkSurfaceCharacterization>())).fIsMipMapped as *const _ as usize
        },
        113usize,
        concat!(
            "Offset of field: ",
            stringify!(SkSurfaceCharacterization),
            "::",
            stringify!(fIsMipMapped)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkSurfaceCharacterization>())).fUsesGLFBO0 as *const _ as usize
        },
        114usize,
        concat!(
            "Offset of field: ",
            stringify!(SkSurfaceCharacterization),
            "::",
            stringify!(fUsesGLFBO0)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkSurfaceCharacterization>())).fVulkanSecondaryCBCompatible
                as *const _ as usize
        },
        115usize,
        concat!(
            "Offset of field: ",
            stringify!(SkSurfaceCharacterization),
            "::",
            stringify!(fVulkanSecondaryCBCompatible)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkSurfaceCharacterization>())).fIsProtected as *const _ as usize
        },
        116usize,
        concat!(
            "Offset of field: ",
            stringify!(SkSurfaceCharacterization),
            "::",
            stringify!(fIsProtected)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkSurfaceCharacterization>())).fSurfaceProps as *const _
                as usize
        },
        120usize,
        concat!(
            "Offset of field: ",
            stringify!(SkSurfaceCharacterization),
            "::",
            stringify!(fSurfaceProps)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK25SkSurfaceCharacterization13createResizedEii"]
    pub fn SkSurfaceCharacterization_createResized(
        this: *const SkSurfaceCharacterization,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
    ) -> SkSurfaceCharacterization;
}
extern "C" {
    #[link_name = "\u{1}_ZNK25SkSurfaceCharacterization12isCompatibleERK16GrBackendTexture"]
    pub fn SkSurfaceCharacterization_isCompatible(
        this: *const SkSurfaceCharacterization,
        arg1: *const GrBackendTexture,
    ) -> bool;
}
impl SkSurfaceCharacterization {
    #[inline]
    pub unsafe fn createResized(
        &self,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
    ) -> SkSurfaceCharacterization {
        SkSurfaceCharacterization_createResized(self, width, height)
    }
    #[inline]
    pub unsafe fn isCompatible(&self, arg1: *const GrBackendTexture) -> bool {
        SkSurfaceCharacterization_isCompatible(self, arg1)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkDeferredDisplayListPriv {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrRenderTargetProxy {
    _unused: [u8; 0],
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub struct SkDeferredDisplayList {
    pub _bindgen_opaque_blob: [u64; 26usize],
}
#[repr(C)]
pub struct SkDeferredDisplayList_LazyProxyData {
    pub _base: SkRefCnt,
    pub fReplayDest: *mut GrRenderTargetProxy,
}
#[test]
fn bindgen_test_layout_SkDeferredDisplayList_LazyProxyData() {
    assert_eq!(
        ::core::mem::size_of::<SkDeferredDisplayList_LazyProxyData>(),
        24usize,
        concat!("Size of: ", stringify!(SkDeferredDisplayList_LazyProxyData))
    );
    assert_eq!(
        ::core::mem::align_of::<SkDeferredDisplayList_LazyProxyData>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(SkDeferredDisplayList_LazyProxyData)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkDeferredDisplayList_LazyProxyData>())).fReplayDest as *const _
                as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkDeferredDisplayList_LazyProxyData),
            "::",
            stringify!(fReplayDest)
        )
    );
}
pub type SkDeferredDisplayList_PendingPathsMap = [u64; 6usize];
#[test]
fn bindgen_test_layout_SkDeferredDisplayList() {
    assert_eq!(
        ::core::mem::size_of::<SkDeferredDisplayList>(),
        208usize,
        concat!("Size of: ", stringify!(SkDeferredDisplayList))
    );
    assert_eq!(
        ::core::mem::align_of::<SkDeferredDisplayList>(),
        8usize,
        concat!("Alignment of ", stringify!(SkDeferredDisplayList))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN21SkDeferredDisplayList4privEv"]
    pub fn SkDeferredDisplayList_priv(
        this: *mut SkDeferredDisplayList,
    ) -> SkDeferredDisplayListPriv;
}
extern "C" {
    #[link_name = "\u{1}_ZNK21SkDeferredDisplayList4privEv"]
    pub fn SkDeferredDisplayList_priv1(
        this: *const SkDeferredDisplayList,
    ) -> SkDeferredDisplayListPriv;
}
extern "C" {
    #[link_name = "\u{1}_ZN21SkDeferredDisplayListC1ERK25SkSurfaceCharacterization5sk_spINS_13LazyProxyDataEE"]
    pub fn SkDeferredDisplayList_SkDeferredDisplayList(
        this: *mut SkDeferredDisplayList,
        characterization: *const SkSurfaceCharacterization,
        arg1: sk_sp<SkDeferredDisplayList_LazyProxyData>,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN21SkDeferredDisplayListD1Ev"]
    pub fn SkDeferredDisplayList_SkDeferredDisplayList_destructor(this: *mut SkDeferredDisplayList);
}
impl SkDeferredDisplayList {
    #[inline]
    pub unsafe fn priv_(&mut self) -> SkDeferredDisplayListPriv {
        SkDeferredDisplayList_priv(self)
    }
    #[inline]
    pub unsafe fn priv1(&self) -> SkDeferredDisplayListPriv {
        SkDeferredDisplayList_priv1(self)
    }
    #[inline]
    pub unsafe fn new(
        characterization: *const SkSurfaceCharacterization,
        arg1: sk_sp<SkDeferredDisplayList_LazyProxyData>,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkDeferredDisplayList_SkDeferredDisplayList(&mut __bindgen_tmp, characterization, arg1);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        SkDeferredDisplayList_SkDeferredDisplayList_destructor(self)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkPromiseImageTexture {
    _unused: [u8; 0],
}
#[repr(C)]
pub struct SkDeferredDisplayListRecorder {
    pub fCharacterization: SkSurfaceCharacterization,
    pub fContext: sk_sp<GrContext>,
    pub fLazyProxyData: sk_sp<SkDeferredDisplayList_LazyProxyData>,
    pub fSurface: sk_sp<SkSurface>,
}
pub type SkDeferredDisplayListRecorder_PromiseImageTextureContext = *mut ::std::os::raw::c_void;
pub type SkDeferredDisplayListRecorder_PromiseImageTextureFulfillProc = ::core::option::Option<
    unsafe extern "C" fn(
        arg1: SkDeferredDisplayListRecorder_PromiseImageTextureContext,
    ) -> sk_sp<SkPromiseImageTexture>,
>;
pub type SkDeferredDisplayListRecorder_PromiseImageTextureReleaseProc = ::core::option::Option<
    unsafe extern "C" fn(arg1: SkDeferredDisplayListRecorder_PromiseImageTextureContext),
>;
pub type SkDeferredDisplayListRecorder_PromiseImageTextureDoneProc = ::core::option::Option<
    unsafe extern "C" fn(arg1: SkDeferredDisplayListRecorder_PromiseImageTextureContext),
>;
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkDeferredDisplayListRecorder_PromiseImageApiVersion {
    kLegacy = 0,
    kNew = 1,
}
#[test]
fn bindgen_test_layout_SkDeferredDisplayListRecorder() {
    assert_eq!(
        ::core::mem::size_of::<SkDeferredDisplayListRecorder>(),
        152usize,
        concat!("Size of: ", stringify!(SkDeferredDisplayListRecorder))
    );
    assert_eq!(
        ::core::mem::align_of::<SkDeferredDisplayListRecorder>(),
        8usize,
        concat!("Alignment of ", stringify!(SkDeferredDisplayListRecorder))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkDeferredDisplayListRecorder>())).fCharacterization as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkDeferredDisplayListRecorder),
            "::",
            stringify!(fCharacterization)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkDeferredDisplayListRecorder>())).fContext as *const _ as usize
        },
        128usize,
        concat!(
            "Offset of field: ",
            stringify!(SkDeferredDisplayListRecorder),
            "::",
            stringify!(fContext)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkDeferredDisplayListRecorder>())).fLazyProxyData as *const _
                as usize
        },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(SkDeferredDisplayListRecorder),
            "::",
            stringify!(fLazyProxyData)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkDeferredDisplayListRecorder>())).fSurface as *const _ as usize
        },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(SkDeferredDisplayListRecorder),
            "::",
            stringify!(fSurface)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN29SkDeferredDisplayListRecorder9getCanvasEv"]
    pub fn SkDeferredDisplayListRecorder_getCanvas(
        this: *mut SkDeferredDisplayListRecorder,
    ) -> *mut SkCanvas;
}
extern "C" {
    #[link_name = "\u{1}_ZN29SkDeferredDisplayListRecorder6detachEv"]
    pub fn SkDeferredDisplayListRecorder_detach(this: *mut SkDeferredDisplayListRecorder) -> u64;
}
extern "C" {
    #[link_name = "\u{1}_ZN29SkDeferredDisplayListRecorder18makePromiseTextureERK15GrBackendFormatii11GrMipMapped15GrSurfaceOrigin11SkColorType11SkAlphaType5sk_spI12SkColorSpaceEPFS7_I21SkPromiseImageTextureEPvEPFvSC_ESG_SC_NS_22PromiseImageApiVersionE"]
    pub fn SkDeferredDisplayListRecorder_makePromiseTexture(
        this: *mut SkDeferredDisplayListRecorder,
        backendFormat: *const GrBackendFormat,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        mipMapped: GrMipMapped,
        origin: GrSurfaceOrigin,
        colorType: SkColorType,
        alphaType: SkAlphaType,
        colorSpace: sk_sp<SkColorSpace>,
        textureFulfillProc: SkDeferredDisplayListRecorder_PromiseImageTextureFulfillProc,
        textureReleaseProc: SkDeferredDisplayListRecorder_PromiseImageTextureReleaseProc,
        textureDoneProc: SkDeferredDisplayListRecorder_PromiseImageTextureDoneProc,
        textureContext: SkDeferredDisplayListRecorder_PromiseImageTextureContext,
        version: SkDeferredDisplayListRecorder_PromiseImageApiVersion,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN29SkDeferredDisplayListRecorder22makeYUVAPromiseTextureE15SkYUVColorSpacePK15GrBackendFormatPK7SkISizePK11SkYUVAIndexii15GrSurfaceOrigin5sk_spI12SkColorSpaceEPFSB_I21SkPromiseImageTextureEPvEPFvSG_ESK_PSG_NS_22PromiseImageApiVersionE"]
    pub fn SkDeferredDisplayListRecorder_makeYUVAPromiseTexture(
        this: *mut SkDeferredDisplayListRecorder,
        yuvColorSpace: SkYUVColorSpace,
        yuvaFormats: *const GrBackendFormat,
        yuvaSizes: *const SkISize,
        yuvaIndices: *const SkYUVAIndex,
        imageWidth: ::std::os::raw::c_int,
        imageHeight: ::std::os::raw::c_int,
        imageOrigin: GrSurfaceOrigin,
        imageColorSpace: sk_sp<SkColorSpace>,
        textureFulfillProc: SkDeferredDisplayListRecorder_PromiseImageTextureFulfillProc,
        textureReleaseProc: SkDeferredDisplayListRecorder_PromiseImageTextureReleaseProc,
        textureDoneProc: SkDeferredDisplayListRecorder_PromiseImageTextureDoneProc,
        textureContexts: *mut SkDeferredDisplayListRecorder_PromiseImageTextureContext,
        version: SkDeferredDisplayListRecorder_PromiseImageApiVersion,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN29SkDeferredDisplayListRecorderC1ERK25SkSurfaceCharacterization"]
    pub fn SkDeferredDisplayListRecorder_SkDeferredDisplayListRecorder(
        this: *mut SkDeferredDisplayListRecorder,
        arg1: *const SkSurfaceCharacterization,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN29SkDeferredDisplayListRecorderD1Ev"]
    pub fn SkDeferredDisplayListRecorder_SkDeferredDisplayListRecorder_destructor(
        this: *mut SkDeferredDisplayListRecorder,
    );
}
impl SkDeferredDisplayListRecorder {
    #[inline]
    pub unsafe fn getCanvas(&mut self) -> *mut SkCanvas {
        SkDeferredDisplayListRecorder_getCanvas(self)
    }
    #[inline]
    pub unsafe fn detach(&mut self) -> u64 {
        SkDeferredDisplayListRecorder_detach(self)
    }
    #[inline]
    pub unsafe fn makePromiseTexture(
        &mut self,
        backendFormat: *const GrBackendFormat,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        mipMapped: GrMipMapped,
        origin: GrSurfaceOrigin,
        colorType: SkColorType,
        alphaType: SkAlphaType,
        colorSpace: sk_sp<SkColorSpace>,
        textureFulfillProc: SkDeferredDisplayListRecorder_PromiseImageTextureFulfillProc,
        textureReleaseProc: SkDeferredDisplayListRecorder_PromiseImageTextureReleaseProc,
        textureDoneProc: SkDeferredDisplayListRecorder_PromiseImageTextureDoneProc,
        textureContext: SkDeferredDisplayListRecorder_PromiseImageTextureContext,
        version: SkDeferredDisplayListRecorder_PromiseImageApiVersion,
    ) -> sk_sp<SkImage> {
        SkDeferredDisplayListRecorder_makePromiseTexture(
            self,
            backendFormat,
            width,
            height,
            mipMapped,
            origin,
            colorType,
            alphaType,
            colorSpace,
            textureFulfillProc,
            textureReleaseProc,
            textureDoneProc,
            textureContext,
            version,
        )
    }
    #[inline]
    pub unsafe fn makeYUVAPromiseTexture(
        &mut self,
        yuvColorSpace: SkYUVColorSpace,
        yuvaFormats: *const GrBackendFormat,
        yuvaSizes: *const SkISize,
        yuvaIndices: *const SkYUVAIndex,
        imageWidth: ::std::os::raw::c_int,
        imageHeight: ::std::os::raw::c_int,
        imageOrigin: GrSurfaceOrigin,
        imageColorSpace: sk_sp<SkColorSpace>,
        textureFulfillProc: SkDeferredDisplayListRecorder_PromiseImageTextureFulfillProc,
        textureReleaseProc: SkDeferredDisplayListRecorder_PromiseImageTextureReleaseProc,
        textureDoneProc: SkDeferredDisplayListRecorder_PromiseImageTextureDoneProc,
        textureContexts: *mut SkDeferredDisplayListRecorder_PromiseImageTextureContext,
        version: SkDeferredDisplayListRecorder_PromiseImageApiVersion,
    ) -> sk_sp<SkImage> {
        SkDeferredDisplayListRecorder_makeYUVAPromiseTexture(
            self,
            yuvColorSpace,
            yuvaFormats,
            yuvaSizes,
            yuvaIndices,
            imageWidth,
            imageHeight,
            imageOrigin,
            imageColorSpace,
            textureFulfillProc,
            textureReleaseProc,
            textureDoneProc,
            textureContexts,
            version,
        )
    }
    #[inline]
    pub unsafe fn new(arg1: *const SkSurfaceCharacterization) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkDeferredDisplayListRecorder_SkDeferredDisplayListRecorder(&mut __bindgen_tmp, arg1);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        SkDeferredDisplayListRecorder_SkDeferredDisplayListRecorder_destructor(self)
    }
}
impl SkBlurStyle {
    pub const kLastEnum_SkBlurStyle: SkBlurStyle = SkBlurStyle::kInner_SkBlurStyle;
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkBlurStyle {
    kNormal_SkBlurStyle = 0,
    kSolid_SkBlurStyle = 1,
    kOuter_SkBlurStyle = 2,
    kInner_SkBlurStyle = 3,
}
#[repr(C)]
pub struct SkDrawLooper {
    pub _base: SkFlattenable,
}
#[repr(C)]
pub struct SkDrawLooper_Context__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
pub struct SkDrawLooper_Context {
    pub vtable_: *const SkDrawLooper_Context__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_SkDrawLooper_Context() {
    assert_eq!(
        ::core::mem::size_of::<SkDrawLooper_Context>(),
        8usize,
        concat!("Size of: ", stringify!(SkDrawLooper_Context))
    );
    assert_eq!(
        ::core::mem::align_of::<SkDrawLooper_Context>(),
        8usize,
        concat!("Alignment of ", stringify!(SkDrawLooper_Context))
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkDrawLooper_BlurShadowRec {
    pub fSigma: SkScalar,
    pub fOffset: SkVector,
    pub fColor: SkColor,
    pub fStyle: SkBlurStyle,
}
#[test]
fn bindgen_test_layout_SkDrawLooper_BlurShadowRec() {
    assert_eq!(
        ::core::mem::size_of::<SkDrawLooper_BlurShadowRec>(),
        20usize,
        concat!("Size of: ", stringify!(SkDrawLooper_BlurShadowRec))
    );
    assert_eq!(
        ::core::mem::align_of::<SkDrawLooper_BlurShadowRec>(),
        4usize,
        concat!("Alignment of ", stringify!(SkDrawLooper_BlurShadowRec))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkDrawLooper_BlurShadowRec>())).fSigma as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkDrawLooper_BlurShadowRec),
            "::",
            stringify!(fSigma)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkDrawLooper_BlurShadowRec>())).fOffset as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkDrawLooper_BlurShadowRec),
            "::",
            stringify!(fOffset)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkDrawLooper_BlurShadowRec>())).fColor as *const _ as usize
        },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(SkDrawLooper_BlurShadowRec),
            "::",
            stringify!(fColor)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkDrawLooper_BlurShadowRec>())).fStyle as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkDrawLooper_BlurShadowRec),
            "::",
            stringify!(fStyle)
        )
    );
}
pub type SkDrawLooper_INHERITED = SkFlattenable;
#[test]
fn bindgen_test_layout_SkDrawLooper() {
    assert_eq!(
        ::core::mem::size_of::<SkDrawLooper>(),
        16usize,
        concat!("Size of: ", stringify!(SkDrawLooper))
    );
    assert_eq!(
        ::core::mem::align_of::<SkDrawLooper>(),
        8usize,
        concat!("Alignment of ", stringify!(SkDrawLooper))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkDrawLooper20canComputeFastBoundsERK7SkPaint"]
    pub fn SkDrawLooper_canComputeFastBounds(
        this: *const SkDrawLooper,
        paint: *const SkPaint,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkDrawLooper17computeFastBoundsERK7SkPaintRK6SkRectPS3_"]
    pub fn SkDrawLooper_computeFastBounds(
        this: *const SkDrawLooper,
        paint: *const SkPaint,
        src: *const SkRect,
        dst: *mut SkRect,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN12SkDrawLooper5applyEP8SkCanvasRK7SkPaintSt8functionIFvS1_S4_EE"]
    pub fn SkDrawLooper_apply(
        this: *mut SkDrawLooper,
        canvas: *mut SkCanvas,
        paint: *const SkPaint,
        arg1: u8,
    );
}
impl SkDrawLooper {
    #[inline]
    pub unsafe fn canComputeFastBounds(&self, paint: *const SkPaint) -> bool {
        SkDrawLooper_canComputeFastBounds(self, paint)
    }
    #[inline]
    pub unsafe fn computeFastBounds(
        &self,
        paint: *const SkPaint,
        src: *const SkRect,
        dst: *mut SkRect,
    ) {
        SkDrawLooper_computeFastBounds(self, paint, src, dst)
    }
    #[inline]
    pub unsafe fn apply(&mut self, canvas: *mut SkCanvas, paint: *const SkPaint, arg1: u8) {
        SkDrawLooper_apply(self, canvas, paint, arg1)
    }
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkDrawLooper13asABlurShadowEPNS_13BlurShadowRecE"]
    pub fn SkDrawLooper_asABlurShadow(
        this: *mut ::std::os::raw::c_void,
        arg1: *mut SkDrawLooper_BlurShadowRec,
    ) -> bool;
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub struct SkDrawable {
    pub _bindgen_opaque_blob: [u64; 2usize],
}
#[repr(C)]
pub struct SkDrawable_GpuDrawHandler__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
pub struct SkDrawable_GpuDrawHandler {
    pub vtable_: *const SkDrawable_GpuDrawHandler__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_SkDrawable_GpuDrawHandler() {
    assert_eq!(
        ::core::mem::size_of::<SkDrawable_GpuDrawHandler>(),
        8usize,
        concat!("Size of: ", stringify!(SkDrawable_GpuDrawHandler))
    );
    assert_eq!(
        ::core::mem::align_of::<SkDrawable_GpuDrawHandler>(),
        8usize,
        concat!("Alignment of ", stringify!(SkDrawable_GpuDrawHandler))
    );
}
#[test]
fn bindgen_test_layout_SkDrawable() {
    assert_eq!(
        ::core::mem::size_of::<SkDrawable>(),
        16usize,
        concat!("Size of: ", stringify!(SkDrawable))
    );
    assert_eq!(
        ::core::mem::align_of::<SkDrawable>(),
        8usize,
        concat!("Alignment of ", stringify!(SkDrawable))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkDrawable4drawEP8SkCanvasPK8SkMatrix"]
    pub fn SkDrawable_draw(this: *mut SkDrawable, arg1: *mut SkCanvas, arg2: *const SkMatrix);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkDrawable4drawEP8SkCanvasff"]
    pub fn SkDrawable_draw1(this: *mut SkDrawable, arg1: *mut SkCanvas, x: SkScalar, y: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkDrawable18newPictureSnapshotEv"]
    pub fn SkDrawable_newPictureSnapshot(this: *mut SkDrawable) -> *mut SkPicture;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkDrawable15getGenerationIDEv"]
    pub fn SkDrawable_getGenerationID(this: *mut SkDrawable) -> u32;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkDrawable9getBoundsEv"]
    pub fn SkDrawable_getBounds(this: *mut SkDrawable) -> SkRect;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkDrawable20notifyDrawingChangedEv"]
    pub fn SkDrawable_notifyDrawingChanged(this: *mut SkDrawable);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkDrawableC2Ev"]
    pub fn SkDrawable_SkDrawable(this: *mut SkDrawable);
}
impl SkDrawable {
    #[inline]
    pub unsafe fn draw(&mut self, arg1: *mut SkCanvas, arg2: *const SkMatrix) {
        SkDrawable_draw(self, arg1, arg2)
    }
    #[inline]
    pub unsafe fn draw1(&mut self, arg1: *mut SkCanvas, x: SkScalar, y: SkScalar) {
        SkDrawable_draw1(self, arg1, x, y)
    }
    #[inline]
    pub unsafe fn newPictureSnapshot(&mut self) -> *mut SkPicture {
        SkDrawable_newPictureSnapshot(self)
    }
    #[inline]
    pub unsafe fn getGenerationID(&mut self) -> u32 {
        SkDrawable_getGenerationID(self)
    }
    #[inline]
    pub unsafe fn getBounds(&mut self) -> SkRect {
        SkDrawable_getBounds(self)
    }
    #[inline]
    pub unsafe fn notifyDrawingChanged(&mut self) {
        SkDrawable_notifyDrawingChanged(self)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkDrawable_SkDrawable(&mut __bindgen_tmp);
        __bindgen_tmp
    }
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkDrawable20onNewPictureSnapshotEv"]
    pub fn SkDrawable_onNewPictureSnapshot(this: *mut ::std::os::raw::c_void) -> *mut SkPicture;
}
#[repr(C)]
pub struct SkDocument {
    pub _base: SkRefCnt,
    pub fStream: *mut SkWStream,
    pub fState: SkDocument_State,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkDocument_State {
    kBetweenPages_State = 0,
    kInPage_State = 1,
    kClosed_State = 2,
}
pub type SkDocument_INHERITED = SkRefCnt;
#[test]
fn bindgen_test_layout_SkDocument() {
    assert_eq!(
        ::core::mem::size_of::<SkDocument>(),
        32usize,
        concat!("Size of: ", stringify!(SkDocument))
    );
    assert_eq!(
        ::core::mem::align_of::<SkDocument>(),
        8usize,
        concat!("Alignment of ", stringify!(SkDocument))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkDocument>())).fStream as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkDocument),
            "::",
            stringify!(fStream)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkDocument>())).fState as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkDocument),
            "::",
            stringify!(fState)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkDocument9beginPageEffPK6SkRect"]
    pub fn SkDocument_beginPage(
        this: *mut SkDocument,
        width: SkScalar,
        height: SkScalar,
        content: *const SkRect,
    ) -> *mut SkCanvas;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkDocument7endPageEv"]
    pub fn SkDocument_endPage(this: *mut SkDocument);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkDocument5closeEv"]
    pub fn SkDocument_close(this: *mut SkDocument);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkDocument5abortEv"]
    pub fn SkDocument_abort(this: *mut SkDocument);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkDocumentC2EP9SkWStream"]
    pub fn SkDocument_SkDocument(this: *mut SkDocument, arg1: *mut SkWStream);
}
impl SkDocument {
    #[inline]
    pub unsafe fn beginPage(
        &mut self,
        width: SkScalar,
        height: SkScalar,
        content: *const SkRect,
    ) -> *mut SkCanvas {
        SkDocument_beginPage(self, width, height, content)
    }
    #[inline]
    pub unsafe fn endPage(&mut self) {
        SkDocument_endPage(self)
    }
    #[inline]
    pub unsafe fn close(&mut self) {
        SkDocument_close(self)
    }
    #[inline]
    pub unsafe fn abort(&mut self) {
        SkDocument_abort(self)
    }
    #[inline]
    pub unsafe fn new(arg1: *mut SkWStream) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkDocument_SkDocument(&mut __bindgen_tmp, arg1);
        __bindgen_tmp
    }
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkDocumentD1Ev"]
    pub fn SkDocument_SkDocument_destructor(this: *mut SkDocument);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkFontArguments {
    pub fCollectionIndex: ::std::os::raw::c_int,
    pub fVariationDesignPosition: SkFontArguments_VariationPosition,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkFontArguments_VariationPosition {
    pub coordinates: *const SkFontArguments_VariationPosition_Coordinate,
    pub coordinateCount: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkFontArguments_VariationPosition_Coordinate {
    pub axis: SkFourByteTag,
    pub value: f32,
}
#[test]
fn bindgen_test_layout_SkFontArguments_VariationPosition_Coordinate() {
    assert_eq!(
        ::core::mem::size_of::<SkFontArguments_VariationPosition_Coordinate>(),
        8usize,
        concat!(
            "Size of: ",
            stringify!(SkFontArguments_VariationPosition_Coordinate)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<SkFontArguments_VariationPosition_Coordinate>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(SkFontArguments_VariationPosition_Coordinate)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkFontArguments_VariationPosition_Coordinate>())).axis
                as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontArguments_VariationPosition_Coordinate),
            "::",
            stringify!(axis)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkFontArguments_VariationPosition_Coordinate>())).value
                as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontArguments_VariationPosition_Coordinate),
            "::",
            stringify!(value)
        )
    );
}
#[test]
fn bindgen_test_layout_SkFontArguments_VariationPosition() {
    assert_eq!(
        ::core::mem::size_of::<SkFontArguments_VariationPosition>(),
        16usize,
        concat!("Size of: ", stringify!(SkFontArguments_VariationPosition))
    );
    assert_eq!(
        ::core::mem::align_of::<SkFontArguments_VariationPosition>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(SkFontArguments_VariationPosition)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkFontArguments_VariationPosition>())).coordinates as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontArguments_VariationPosition),
            "::",
            stringify!(coordinates)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkFontArguments_VariationPosition>())).coordinateCount
                as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontArguments_VariationPosition),
            "::",
            stringify!(coordinateCount)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkFontArguments_Axis {
    pub fTag: SkFourByteTag,
    pub fStyleValue: f32,
}
#[test]
fn bindgen_test_layout_SkFontArguments_Axis() {
    assert_eq!(
        ::core::mem::size_of::<SkFontArguments_Axis>(),
        8usize,
        concat!("Size of: ", stringify!(SkFontArguments_Axis))
    );
    assert_eq!(
        ::core::mem::align_of::<SkFontArguments_Axis>(),
        4usize,
        concat!("Alignment of ", stringify!(SkFontArguments_Axis))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFontArguments_Axis>())).fTag as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontArguments_Axis),
            "::",
            stringify!(fTag)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkFontArguments_Axis>())).fStyleValue as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontArguments_Axis),
            "::",
            stringify!(fStyleValue)
        )
    );
}
#[test]
fn bindgen_test_layout_SkFontArguments() {
    assert_eq!(
        ::core::mem::size_of::<SkFontArguments>(),
        24usize,
        concat!("Size of: ", stringify!(SkFontArguments))
    );
    assert_eq!(
        ::core::mem::align_of::<SkFontArguments>(),
        8usize,
        concat!("Alignment of ", stringify!(SkFontArguments))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkFontArguments>())).fCollectionIndex as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontArguments),
            "::",
            stringify!(fCollectionIndex)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkFontArguments>())).fVariationDesignPosition as *const _
                as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontArguments),
            "::",
            stringify!(fVariationDesignPosition)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkFontParameters_Variation_Axis {
    pub tag: SkFourByteTag,
    pub min: f32,
    pub def: f32,
    pub max: f32,
    pub flags: u16,
}
pub const SkFontParameters_Variation_Axis_HIDDEN: u16 = 1;
#[test]
fn bindgen_test_layout_SkFontParameters_Variation_Axis() {
    assert_eq!(
        ::core::mem::size_of::<SkFontParameters_Variation_Axis>(),
        20usize,
        concat!("Size of: ", stringify!(SkFontParameters_Variation_Axis))
    );
    assert_eq!(
        ::core::mem::align_of::<SkFontParameters_Variation_Axis>(),
        4usize,
        concat!("Alignment of ", stringify!(SkFontParameters_Variation_Axis))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkFontParameters_Variation_Axis>())).tag as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontParameters_Variation_Axis),
            "::",
            stringify!(tag)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkFontParameters_Variation_Axis>())).min as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontParameters_Variation_Axis),
            "::",
            stringify!(min)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkFontParameters_Variation_Axis>())).def as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontParameters_Variation_Axis),
            "::",
            stringify!(def)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkFontParameters_Variation_Axis>())).max as *const _ as usize
        },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontParameters_Variation_Axis),
            "::",
            stringify!(max)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkFontParameters_Variation_Axis>())).flags as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontParameters_Variation_Axis),
            "::",
            stringify!(flags)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkFontStyle {
    pub fValue: u32,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkFontStyle_Weight {
    kInvisible_Weight = 0,
    kThin_Weight = 100,
    kExtraLight_Weight = 200,
    kLight_Weight = 300,
    kNormal_Weight = 400,
    kMedium_Weight = 500,
    kSemiBold_Weight = 600,
    kBold_Weight = 700,
    kExtraBold_Weight = 800,
    kBlack_Weight = 900,
    kExtraBlack_Weight = 1000,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkFontStyle_Width {
    kUltraCondensed_Width = 1,
    kExtraCondensed_Width = 2,
    kCondensed_Width = 3,
    kSemiCondensed_Width = 4,
    kNormal_Width = 5,
    kSemiExpanded_Width = 6,
    kExpanded_Width = 7,
    kExtraExpanded_Width = 8,
    kUltraExpanded_Width = 9,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkFontStyle_Slant {
    kUpright_Slant = 0,
    kItalic_Slant = 1,
    kOblique_Slant = 2,
}
#[test]
fn bindgen_test_layout_SkFontStyle() {
    assert_eq!(
        ::core::mem::size_of::<SkFontStyle>(),
        4usize,
        concat!("Size of: ", stringify!(SkFontStyle))
    );
    assert_eq!(
        ::core::mem::align_of::<SkFontStyle>(),
        4usize,
        concat!("Alignment of ", stringify!(SkFontStyle))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFontStyle>())).fValue as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontStyle),
            "::",
            stringify!(fValue)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkDescriptor {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkFontData {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkFontDescriptor {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkScalerContext {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkAdvancedTypefaceMetrics {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkScalerContextEffects {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkScalerContextRec {
    _unused: [u8; 0],
}
pub type SkFontID = u32;
pub type SkFontTableTag = u32;
#[repr(C)]
pub struct SkTypeface {
    pub _base: SkWeakRefCnt,
    pub fUniqueID: SkFontID,
    pub fStyle: SkFontStyle,
    pub fBounds: SkRect,
    pub fBoundsOnce: SkOnce,
    pub fIsFixedPitch: bool,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkTypeface_SerializeBehavior {
    kDoIncludeData = 0,
    kDontIncludeData = 1,
    kIncludeDataIfLocal = 2,
}
#[repr(C)]
pub struct SkTypeface_LocalizedString {
    pub fString: SkString,
    pub fLanguage: SkString,
}
#[test]
fn bindgen_test_layout_SkTypeface_LocalizedString() {
    assert_eq!(
        ::core::mem::size_of::<SkTypeface_LocalizedString>(),
        16usize,
        concat!("Size of: ", stringify!(SkTypeface_LocalizedString))
    );
    assert_eq!(
        ::core::mem::align_of::<SkTypeface_LocalizedString>(),
        8usize,
        concat!("Alignment of ", stringify!(SkTypeface_LocalizedString))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkTypeface_LocalizedString>())).fString as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTypeface_LocalizedString),
            "::",
            stringify!(fString)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkTypeface_LocalizedString>())).fLanguage as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTypeface_LocalizedString),
            "::",
            stringify!(fLanguage)
        )
    );
}
#[repr(C)]
pub struct SkTypeface_LocalizedStrings__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
pub struct SkTypeface_LocalizedStrings {
    pub vtable_: *const SkTypeface_LocalizedStrings__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_SkTypeface_LocalizedStrings() {
    assert_eq!(
        ::core::mem::size_of::<SkTypeface_LocalizedStrings>(),
        8usize,
        concat!("Size of: ", stringify!(SkTypeface_LocalizedStrings))
    );
    assert_eq!(
        ::core::mem::align_of::<SkTypeface_LocalizedStrings>(),
        8usize,
        concat!("Alignment of ", stringify!(SkTypeface_LocalizedStrings))
    );
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkTypeface_Style {
    kNormal = 0,
    kBold = 1,
    kItalic = 2,
    kBoldItalic = 3,
}
pub type SkTypeface_INHERITED = SkWeakRefCnt;
#[test]
fn bindgen_test_layout_SkTypeface() {
    assert_eq!(
        ::core::mem::size_of::<SkTypeface>(),
        48usize,
        concat!("Size of: ", stringify!(SkTypeface))
    );
    assert_eq!(
        ::core::mem::align_of::<SkTypeface>(),
        8usize,
        concat!("Alignment of ", stringify!(SkTypeface))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTypeface>())).fUniqueID as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTypeface),
            "::",
            stringify!(fUniqueID)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTypeface>())).fStyle as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTypeface),
            "::",
            stringify!(fStyle)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTypeface>())).fBounds as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTypeface),
            "::",
            stringify!(fBounds)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTypeface>())).fBoundsOnce as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTypeface),
            "::",
            stringify!(fBoundsOnce)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTypeface>())).fIsFixedPitch as *const _ as usize },
        41usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTypeface),
            "::",
            stringify!(fIsFixedPitch)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface26getVariationDesignPositionEPN15SkFontArguments17VariationPosition10CoordinateEi"]
    pub fn SkTypeface_getVariationDesignPosition(
        this: *const SkTypeface,
        coordinates: *mut SkFontArguments_VariationPosition_Coordinate,
        coordinateCount: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface28getVariationDesignParametersEPN16SkFontParameters9Variation4AxisEi"]
    pub fn SkTypeface_getVariationDesignParameters(
        this: *const SkTypeface,
        parameters: *mut SkFontParameters_Variation_Axis,
        parameterCount: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkTypeface8UniqueIDEPKS_"]
    pub fn SkTypeface_UniqueID(face: *const SkTypeface) -> SkFontID;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkTypeface5EqualEPKS_S1_"]
    pub fn SkTypeface_Equal(facea: *const SkTypeface, faceb: *const SkTypeface) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkTypeface11MakeDefaultEv"]
    pub fn SkTypeface_MakeDefault() -> sk_sp<SkTypeface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkTypeface12MakeFromNameEPKc11SkFontStyle"]
    pub fn SkTypeface_MakeFromName(
        familyName: *const ::std::os::raw::c_char,
        fontStyle: SkFontStyle,
    ) -> sk_sp<SkTypeface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkTypeface12MakeFromFileEPKci"]
    pub fn SkTypeface_MakeFromFile(
        path: *const ::std::os::raw::c_char,
        index: ::std::os::raw::c_int,
    ) -> sk_sp<SkTypeface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkTypeface14MakeFromStreamESt10unique_ptrI13SkStreamAssetSt14default_deleteIS1_EEi"]
    pub fn SkTypeface_MakeFromStream(
        stream: u64,
        index: ::std::os::raw::c_int,
    ) -> sk_sp<SkTypeface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkTypeface12MakeFromDataE5sk_spI6SkDataEi"]
    pub fn SkTypeface_MakeFromData(
        arg1: sk_sp<SkData>,
        index: ::std::os::raw::c_int,
    ) -> sk_sp<SkTypeface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkTypeface16MakeFromFontDataESt10unique_ptrI10SkFontDataSt14default_deleteIS1_EE"]
    pub fn SkTypeface_MakeFromFontData(arg1: u8) -> sk_sp<SkTypeface>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface9makeCloneERK15SkFontArguments"]
    pub fn SkTypeface_makeClone(
        this: *const SkTypeface,
        arg1: *const SkFontArguments,
    ) -> sk_sp<SkTypeface>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface9serializeEP9SkWStreamNS_17SerializeBehaviorE"]
    pub fn SkTypeface_serialize(
        this: *const SkTypeface,
        arg1: *mut SkWStream,
        arg2: SkTypeface_SerializeBehavior,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface9serializeENS_17SerializeBehaviorE"]
    pub fn SkTypeface_serialize1(
        this: *const SkTypeface,
        arg1: SkTypeface_SerializeBehavior,
    ) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkTypeface15MakeDeserializeEP8SkStream"]
    pub fn SkTypeface_MakeDeserialize(arg1: *mut SkStream) -> sk_sp<SkTypeface>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface16unicharsToGlyphsEPKiiPt"]
    pub fn SkTypeface_unicharsToGlyphs(
        this: *const SkTypeface,
        uni: *const SkUnichar,
        count: ::std::os::raw::c_int,
        glyphs: *mut SkGlyphID,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface14unicharToGlyphEi"]
    pub fn SkTypeface_unicharToGlyph(this: *const SkTypeface, unichar: SkUnichar) -> SkGlyphID;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface11countGlyphsEv"]
    pub fn SkTypeface_countGlyphs(this: *const SkTypeface) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface11countTablesEv"]
    pub fn SkTypeface_countTables(this: *const SkTypeface) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface12getTableTagsEPj"]
    pub fn SkTypeface_getTableTags(
        this: *const SkTypeface,
        tags: *mut SkFontTableTag,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface12getTableSizeEj"]
    pub fn SkTypeface_getTableSize(this: *const SkTypeface, arg1: SkFontTableTag) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface12getTableDataEjmmPv"]
    pub fn SkTypeface_getTableData(
        this: *const SkTypeface,
        tag: SkFontTableTag,
        offset: usize,
        length: usize,
        data: *mut ::std::os::raw::c_void,
    ) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface13copyTableDataEj"]
    pub fn SkTypeface_copyTableData(this: *const SkTypeface, tag: SkFontTableTag) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface13getUnitsPerEmEv"]
    pub fn SkTypeface_getUnitsPerEm(this: *const SkTypeface) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface25getKerningPairAdjustmentsEPKtiPi"]
    pub fn SkTypeface_getKerningPairAdjustments(
        this: *const SkTypeface,
        glyphs: *const SkGlyphID,
        count: ::std::os::raw::c_int,
        adjustments: *mut i32,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface24createFamilyNameIteratorEv"]
    pub fn SkTypeface_createFamilyNameIterator(
        this: *const SkTypeface,
    ) -> *mut SkTypeface_LocalizedStrings;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface13getFamilyNameEP8SkString"]
    pub fn SkTypeface_getFamilyName(this: *const SkTypeface, name: *mut SkString);
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface10openStreamEPi"]
    pub fn SkTypeface_openStream(
        this: *const SkTypeface,
        ttcIndex: *mut ::std::os::raw::c_int,
    ) -> u64;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface12makeFontDataEv"]
    pub fn SkTypeface_makeFontData(this: *const SkTypeface) -> u8;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface19createScalerContextERK22SkScalerContextEffectsPK12SkDescriptorb"]
    pub fn SkTypeface_createScalerContext(
        this: *const SkTypeface,
        arg1: *const SkScalerContextEffects,
        arg2: *const SkDescriptor,
        allowFailure: bool,
    ) -> u8;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface9getBoundsEv"]
    pub fn SkTypeface_getBounds(this: *const SkTypeface) -> SkRect;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkTypefaceC2ERK11SkFontStyleb"]
    pub fn SkTypeface_SkTypeface(
        this: *mut SkTypeface,
        style: *const SkFontStyle,
        isFixedPitch: bool,
    );
}
impl SkTypeface {
    #[inline]
    pub unsafe fn getVariationDesignPosition(
        &self,
        coordinates: *mut SkFontArguments_VariationPosition_Coordinate,
        coordinateCount: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        SkTypeface_getVariationDesignPosition(self, coordinates, coordinateCount)
    }
    #[inline]
    pub unsafe fn getVariationDesignParameters(
        &self,
        parameters: *mut SkFontParameters_Variation_Axis,
        parameterCount: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        SkTypeface_getVariationDesignParameters(self, parameters, parameterCount)
    }
    #[inline]
    pub unsafe fn UniqueID(face: *const SkTypeface) -> SkFontID {
        SkTypeface_UniqueID(face)
    }
    #[inline]
    pub unsafe fn Equal(facea: *const SkTypeface, faceb: *const SkTypeface) -> bool {
        SkTypeface_Equal(facea, faceb)
    }
    #[inline]
    pub unsafe fn MakeDefault() -> sk_sp<SkTypeface> {
        SkTypeface_MakeDefault()
    }
    #[inline]
    pub unsafe fn MakeFromName(
        familyName: *const ::std::os::raw::c_char,
        fontStyle: SkFontStyle,
    ) -> sk_sp<SkTypeface> {
        SkTypeface_MakeFromName(familyName, fontStyle)
    }
    #[inline]
    pub unsafe fn MakeFromFile(
        path: *const ::std::os::raw::c_char,
        index: ::std::os::raw::c_int,
    ) -> sk_sp<SkTypeface> {
        SkTypeface_MakeFromFile(path, index)
    }
    #[inline]
    pub unsafe fn MakeFromStream(stream: u64, index: ::std::os::raw::c_int) -> sk_sp<SkTypeface> {
        SkTypeface_MakeFromStream(stream, index)
    }
    #[inline]
    pub unsafe fn MakeFromData(
        arg1: sk_sp<SkData>,
        index: ::std::os::raw::c_int,
    ) -> sk_sp<SkTypeface> {
        SkTypeface_MakeFromData(arg1, index)
    }
    #[inline]
    pub unsafe fn MakeFromFontData(arg1: u8) -> sk_sp<SkTypeface> {
        SkTypeface_MakeFromFontData(arg1)
    }
    #[inline]
    pub unsafe fn makeClone(&self, arg1: *const SkFontArguments) -> sk_sp<SkTypeface> {
        SkTypeface_makeClone(self, arg1)
    }
    #[inline]
    pub unsafe fn serialize(&self, arg1: *mut SkWStream, arg2: SkTypeface_SerializeBehavior) {
        SkTypeface_serialize(self, arg1, arg2)
    }
    #[inline]
    pub unsafe fn serialize1(&self, arg1: SkTypeface_SerializeBehavior) -> sk_sp<SkData> {
        SkTypeface_serialize1(self, arg1)
    }
    #[inline]
    pub unsafe fn MakeDeserialize(arg1: *mut SkStream) -> sk_sp<SkTypeface> {
        SkTypeface_MakeDeserialize(arg1)
    }
    #[inline]
    pub unsafe fn unicharsToGlyphs(
        &self,
        uni: *const SkUnichar,
        count: ::std::os::raw::c_int,
        glyphs: *mut SkGlyphID,
    ) {
        SkTypeface_unicharsToGlyphs(self, uni, count, glyphs)
    }
    #[inline]
    pub unsafe fn unicharToGlyph(&self, unichar: SkUnichar) -> SkGlyphID {
        SkTypeface_unicharToGlyph(self, unichar)
    }
    #[inline]
    pub unsafe fn countGlyphs(&self) -> ::std::os::raw::c_int {
        SkTypeface_countGlyphs(self)
    }
    #[inline]
    pub unsafe fn countTables(&self) -> ::std::os::raw::c_int {
        SkTypeface_countTables(self)
    }
    #[inline]
    pub unsafe fn getTableTags(&self, tags: *mut SkFontTableTag) -> ::std::os::raw::c_int {
        SkTypeface_getTableTags(self, tags)
    }
    #[inline]
    pub unsafe fn getTableSize(&self, arg1: SkFontTableTag) -> usize {
        SkTypeface_getTableSize(self, arg1)
    }
    #[inline]
    pub unsafe fn getTableData(
        &self,
        tag: SkFontTableTag,
        offset: usize,
        length: usize,
        data: *mut ::std::os::raw::c_void,
    ) -> usize {
        SkTypeface_getTableData(self, tag, offset, length, data)
    }
    #[inline]
    pub unsafe fn copyTableData(&self, tag: SkFontTableTag) -> sk_sp<SkData> {
        SkTypeface_copyTableData(self, tag)
    }
    #[inline]
    pub unsafe fn getUnitsPerEm(&self) -> ::std::os::raw::c_int {
        SkTypeface_getUnitsPerEm(self)
    }
    #[inline]
    pub unsafe fn getKerningPairAdjustments(
        &self,
        glyphs: *const SkGlyphID,
        count: ::std::os::raw::c_int,
        adjustments: *mut i32,
    ) -> bool {
        SkTypeface_getKerningPairAdjustments(self, glyphs, count, adjustments)
    }
    #[inline]
    pub unsafe fn createFamilyNameIterator(&self) -> *mut SkTypeface_LocalizedStrings {
        SkTypeface_createFamilyNameIterator(self)
    }
    #[inline]
    pub unsafe fn getFamilyName(&self, name: *mut SkString) {
        SkTypeface_getFamilyName(self, name)
    }
    #[inline]
    pub unsafe fn openStream(&self, ttcIndex: *mut ::std::os::raw::c_int) -> u64 {
        SkTypeface_openStream(self, ttcIndex)
    }
    #[inline]
    pub unsafe fn makeFontData(&self) -> u8 {
        SkTypeface_makeFontData(self)
    }
    #[inline]
    pub unsafe fn createScalerContext(
        &self,
        arg1: *const SkScalerContextEffects,
        arg2: *const SkDescriptor,
        allowFailure: bool,
    ) -> u8 {
        SkTypeface_createScalerContext(self, arg1, arg2, allowFailure)
    }
    #[inline]
    pub unsafe fn getBounds(&self) -> SkRect {
        SkTypeface_getBounds(self)
    }
    #[inline]
    pub unsafe fn new(style: *const SkFontStyle, isFixedPitch: bool) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkTypeface_SkTypeface(&mut __bindgen_tmp, style, isFixedPitch);
        __bindgen_tmp
    }
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkTypefaceD1Ev"]
    pub fn SkTypeface_SkTypeface_destructor(this: *mut SkTypeface);
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface14onMakeFontDataEv"]
    pub fn SkTypeface_onMakeFontData(this: *mut ::std::os::raw::c_void) -> u8;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface27onGetKerningPairAdjustmentsEPKtiPi"]
    pub fn SkTypeface_onGetKerningPairAdjustments(
        this: *mut ::std::os::raw::c_void,
        glyphs: *const SkGlyphID,
        count: ::std::os::raw::c_int,
        adjustments: *mut i32,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface15onCopyTableDataEj"]
    pub fn SkTypeface_onCopyTableData(
        this: *mut ::std::os::raw::c_void,
        arg1: SkFontTableTag,
    ) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTypeface15onComputeBoundsEP6SkRect"]
    pub fn SkTypeface_onComputeBounds(this: *mut ::std::os::raw::c_void, arg1: *mut SkRect)
        -> bool;
}
#[repr(C)]
pub struct SkFont {
    pub fTypeface: sk_sp<SkTypeface>,
    pub fSize: SkScalar,
    pub fScaleX: SkScalar,
    pub fSkewX: SkScalar,
    pub fFlags: u8,
    pub fEdging: u8,
    pub fHinting: u8,
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkFont_Edging {
    kAlias = 0,
    kAntiAlias = 1,
    kSubpixelAntiAlias = 2,
}
pub const SkFont_PrivFlags_kForceAutoHinting_PrivFlag: SkFont_PrivFlags = 1;
pub const SkFont_PrivFlags_kEmbeddedBitmaps_PrivFlag: SkFont_PrivFlags = 2;
pub const SkFont_PrivFlags_kSubpixel_PrivFlag: SkFont_PrivFlags = 4;
pub const SkFont_PrivFlags_kLinearMetrics_PrivFlag: SkFont_PrivFlags = 8;
pub const SkFont_PrivFlags_kEmbolden_PrivFlag: SkFont_PrivFlags = 16;
pub type SkFont_PrivFlags = u32;
pub const SkFont_kAllFlags: ::std::os::raw::c_uint = 31;
#[test]
fn bindgen_test_layout_SkFont() {
    assert_eq!(
        ::core::mem::size_of::<SkFont>(),
        24usize,
        concat!("Size of: ", stringify!(SkFont))
    );
    assert_eq!(
        ::core::mem::align_of::<SkFont>(),
        8usize,
        concat!("Alignment of ", stringify!(SkFont))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFont>())).fTypeface as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFont),
            "::",
            stringify!(fTypeface)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFont>())).fSize as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFont),
            "::",
            stringify!(fSize)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFont>())).fScaleX as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFont),
            "::",
            stringify!(fScaleX)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFont>())).fSkewX as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFont),
            "::",
            stringify!(fSkewX)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFont>())).fFlags as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFont),
            "::",
            stringify!(fFlags)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFont>())).fEdging as *const _ as usize },
        21usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFont),
            "::",
            stringify!(fEdging)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFont>())).fHinting as *const _ as usize },
        22usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFont),
            "::",
            stringify!(fHinting)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkFont19setForceAutoHintingEb"]
    pub fn SkFont_setForceAutoHinting(this: *mut SkFont, forceAutoHinting: bool);
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkFont18setEmbeddedBitmapsEb"]
    pub fn SkFont_setEmbeddedBitmaps(this: *mut SkFont, embeddedBitmaps: bool);
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkFont11setSubpixelEb"]
    pub fn SkFont_setSubpixel(this: *mut SkFont, subpixel: bool);
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkFont16setLinearMetricsEb"]
    pub fn SkFont_setLinearMetrics(this: *mut SkFont, linearMetrics: bool);
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkFont11setEmboldenEb"]
    pub fn SkFont_setEmbolden(this: *mut SkFont, embolden: bool);
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkFont9setEdgingENS_6EdgingE"]
    pub fn SkFont_setEdging(this: *mut SkFont, edging: SkFont_Edging);
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkFont10setHintingE13SkFontHinting"]
    pub fn SkFont_setHinting(this: *mut SkFont, hintingLevel: SkFontHinting);
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkFont12makeWithSizeEf"]
    pub fn SkFont_makeWithSize(this: *const SkFont, size: SkScalar) -> SkFont;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkFont20getTypefaceOrDefaultEv"]
    pub fn SkFont_getTypefaceOrDefault(this: *const SkFont) -> *mut SkTypeface;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkFont20refTypefaceOrDefaultEv"]
    pub fn SkFont_refTypefaceOrDefault(this: *const SkFont) -> sk_sp<SkTypeface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkFont7setSizeEf"]
    pub fn SkFont_setSize(this: *mut SkFont, textSize: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkFont9setScaleXEf"]
    pub fn SkFont_setScaleX(this: *mut SkFont, scaleX: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkFont8setSkewXEf"]
    pub fn SkFont_setSkewX(this: *mut SkFont, skewX: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkFont12textToGlyphsEPKvm14SkTextEncodingPti"]
    pub fn SkFont_textToGlyphs(
        this: *const SkFont,
        text: *const ::std::os::raw::c_void,
        byteLength: usize,
        encoding: SkTextEncoding,
        glyphs: *mut SkGlyphID,
        maxGlyphCount: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkFont14unicharToGlyphEi"]
    pub fn SkFont_unicharToGlyph(this: *const SkFont, uni: SkUnichar) -> SkGlyphID;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkFont16unicharsToGlyphsEPKiiPt"]
    pub fn SkFont_unicharsToGlyphs(
        this: *const SkFont,
        uni: *const SkUnichar,
        count: ::std::os::raw::c_int,
        glyphs: *mut SkGlyphID,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkFont11measureTextEPKvm14SkTextEncodingP6SkRectPK7SkPaint"]
    pub fn SkFont_measureText(
        this: *const SkFont,
        text: *const ::std::os::raw::c_void,
        byteLength: usize,
        encoding: SkTextEncoding,
        bounds: *mut SkRect,
        paint: *const SkPaint,
    ) -> SkScalar;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkFont15getWidthsBoundsEPKtiPfP6SkRectPK7SkPaint"]
    pub fn SkFont_getWidthsBounds(
        this: *const SkFont,
        glyphs: *const SkGlyphID,
        count: ::std::os::raw::c_int,
        widths: *mut SkScalar,
        bounds: *mut SkRect,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkFont6getPosEPKtiP7SkPointS2_"]
    pub fn SkFont_getPos(
        this: *const SkFont,
        glyphs: *const SkGlyphID,
        count: ::std::os::raw::c_int,
        pos: *mut SkPoint,
        origin: SkPoint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkFont7getXPosEPKtiPff"]
    pub fn SkFont_getXPos(
        this: *const SkFont,
        glyphs: *const SkGlyphID,
        count: ::std::os::raw::c_int,
        xpos: *mut SkScalar,
        origin: SkScalar,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkFont7getPathEtP6SkPath"]
    pub fn SkFont_getPath(this: *const SkFont, glyphID: SkGlyphID, path: *mut SkPath) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkFont8getPathsEPKtiPFvPK6SkPathRK8SkMatrixPvES8_"]
    pub fn SkFont_getPaths(
        this: *const SkFont,
        glyphIDs: *const SkGlyphID,
        count: ::std::os::raw::c_int,
        glyphPathProc: ::core::option::Option<
            unsafe extern "C" fn(
                pathOrNull: *const SkPath,
                mx: *const SkMatrix,
                ctx: *mut ::std::os::raw::c_void,
            ),
        >,
        ctx: *mut ::std::os::raw::c_void,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkFont10getMetricsEP13SkFontMetrics"]
    pub fn SkFont_getMetrics(this: *const SkFont, metrics: *mut SkFontMetrics) -> SkScalar;
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkFont4dumpEv"]
    pub fn SkFont_dump(this: *const SkFont);
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkFontC1Ev"]
    pub fn SkFont_SkFont(this: *mut SkFont);
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkFontC1E5sk_spI10SkTypefaceEf"]
    pub fn SkFont_SkFont1(this: *mut SkFont, typeface: sk_sp<SkTypeface>, size: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkFontC1E5sk_spI10SkTypefaceE"]
    pub fn SkFont_SkFont2(this: *mut SkFont, typeface: sk_sp<SkTypeface>);
}
extern "C" {
    #[link_name = "\u{1}_ZN6SkFontC1E5sk_spI10SkTypefaceEfff"]
    pub fn SkFont_SkFont3(
        this: *mut SkFont,
        typeface: sk_sp<SkTypeface>,
        size: SkScalar,
        scaleX: SkScalar,
        skewX: SkScalar,
    );
}
impl SkFont {
    #[inline]
    pub unsafe fn setForceAutoHinting(&mut self, forceAutoHinting: bool) {
        SkFont_setForceAutoHinting(self, forceAutoHinting)
    }
    #[inline]
    pub unsafe fn setEmbeddedBitmaps(&mut self, embeddedBitmaps: bool) {
        SkFont_setEmbeddedBitmaps(self, embeddedBitmaps)
    }
    #[inline]
    pub unsafe fn setSubpixel(&mut self, subpixel: bool) {
        SkFont_setSubpixel(self, subpixel)
    }
    #[inline]
    pub unsafe fn setLinearMetrics(&mut self, linearMetrics: bool) {
        SkFont_setLinearMetrics(self, linearMetrics)
    }
    #[inline]
    pub unsafe fn setEmbolden(&mut self, embolden: bool) {
        SkFont_setEmbolden(self, embolden)
    }
    #[inline]
    pub unsafe fn setEdging(&mut self, edging: SkFont_Edging) {
        SkFont_setEdging(self, edging)
    }
    #[inline]
    pub unsafe fn setHinting(&mut self, hintingLevel: SkFontHinting) {
        SkFont_setHinting(self, hintingLevel)
    }
    #[inline]
    pub unsafe fn makeWithSize(&self, size: SkScalar) -> SkFont {
        SkFont_makeWithSize(self, size)
    }
    #[inline]
    pub unsafe fn getTypefaceOrDefault(&self) -> *mut SkTypeface {
        SkFont_getTypefaceOrDefault(self)
    }
    #[inline]
    pub unsafe fn refTypefaceOrDefault(&self) -> sk_sp<SkTypeface> {
        SkFont_refTypefaceOrDefault(self)
    }
    #[inline]
    pub unsafe fn setSize(&mut self, textSize: SkScalar) {
        SkFont_setSize(self, textSize)
    }
    #[inline]
    pub unsafe fn setScaleX(&mut self, scaleX: SkScalar) {
        SkFont_setScaleX(self, scaleX)
    }
    #[inline]
    pub unsafe fn setSkewX(&mut self, skewX: SkScalar) {
        SkFont_setSkewX(self, skewX)
    }
    #[inline]
    pub unsafe fn textToGlyphs(
        &self,
        text: *const ::std::os::raw::c_void,
        byteLength: usize,
        encoding: SkTextEncoding,
        glyphs: *mut SkGlyphID,
        maxGlyphCount: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        SkFont_textToGlyphs(self, text, byteLength, encoding, glyphs, maxGlyphCount)
    }
    #[inline]
    pub unsafe fn unicharToGlyph(&self, uni: SkUnichar) -> SkGlyphID {
        SkFont_unicharToGlyph(self, uni)
    }
    #[inline]
    pub unsafe fn unicharsToGlyphs(
        &self,
        uni: *const SkUnichar,
        count: ::std::os::raw::c_int,
        glyphs: *mut SkGlyphID,
    ) {
        SkFont_unicharsToGlyphs(self, uni, count, glyphs)
    }
    #[inline]
    pub unsafe fn measureText(
        &self,
        text: *const ::std::os::raw::c_void,
        byteLength: usize,
        encoding: SkTextEncoding,
        bounds: *mut SkRect,
        paint: *const SkPaint,
    ) -> SkScalar {
        SkFont_measureText(self, text, byteLength, encoding, bounds, paint)
    }
    #[inline]
    pub unsafe fn getWidthsBounds(
        &self,
        glyphs: *const SkGlyphID,
        count: ::std::os::raw::c_int,
        widths: *mut SkScalar,
        bounds: *mut SkRect,
        paint: *const SkPaint,
    ) {
        SkFont_getWidthsBounds(self, glyphs, count, widths, bounds, paint)
    }
    #[inline]
    pub unsafe fn getPos(
        &self,
        glyphs: *const SkGlyphID,
        count: ::std::os::raw::c_int,
        pos: *mut SkPoint,
        origin: SkPoint,
    ) {
        SkFont_getPos(self, glyphs, count, pos, origin)
    }
    #[inline]
    pub unsafe fn getXPos(
        &self,
        glyphs: *const SkGlyphID,
        count: ::std::os::raw::c_int,
        xpos: *mut SkScalar,
        origin: SkScalar,
    ) {
        SkFont_getXPos(self, glyphs, count, xpos, origin)
    }
    #[inline]
    pub unsafe fn getPath(&self, glyphID: SkGlyphID, path: *mut SkPath) -> bool {
        SkFont_getPath(self, glyphID, path)
    }
    #[inline]
    pub unsafe fn getPaths(
        &self,
        glyphIDs: *const SkGlyphID,
        count: ::std::os::raw::c_int,
        glyphPathProc: ::core::option::Option<
            unsafe extern "C" fn(
                pathOrNull: *const SkPath,
                mx: *const SkMatrix,
                ctx: *mut ::std::os::raw::c_void,
            ),
        >,
        ctx: *mut ::std::os::raw::c_void,
    ) {
        SkFont_getPaths(self, glyphIDs, count, glyphPathProc, ctx)
    }
    #[inline]
    pub unsafe fn getMetrics(&self, metrics: *mut SkFontMetrics) -> SkScalar {
        SkFont_getMetrics(self, metrics)
    }
    #[inline]
    pub unsafe fn dump(&self) {
        SkFont_dump(self)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkFont_SkFont(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(typeface: sk_sp<SkTypeface>, size: SkScalar) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkFont_SkFont1(&mut __bindgen_tmp, typeface, size);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new2(typeface: sk_sp<SkTypeface>) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkFont_SkFont2(&mut __bindgen_tmp, typeface);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new3(
        typeface: sk_sp<SkTypeface>,
        size: SkScalar,
        scaleX: SkScalar,
        skewX: SkScalar,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkFont_SkFont3(&mut __bindgen_tmp, typeface, size, scaleX, skewX);
        __bindgen_tmp
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkFontMetrics {
    pub fFlags: u32,
    pub fTop: SkScalar,
    pub fAscent: SkScalar,
    pub fDescent: SkScalar,
    pub fBottom: SkScalar,
    pub fLeading: SkScalar,
    pub fAvgCharWidth: SkScalar,
    pub fMaxCharWidth: SkScalar,
    pub fXMin: SkScalar,
    pub fXMax: SkScalar,
    pub fXHeight: SkScalar,
    pub fCapHeight: SkScalar,
    pub fUnderlineThickness: SkScalar,
    pub fUnderlinePosition: SkScalar,
    pub fStrikeoutThickness: SkScalar,
    pub fStrikeoutPosition: SkScalar,
}
pub const SkFontMetrics_FontMetricsFlags_kUnderlineThicknessIsValid_Flag:
    SkFontMetrics_FontMetricsFlags = 1;
pub const SkFontMetrics_FontMetricsFlags_kUnderlinePositionIsValid_Flag:
    SkFontMetrics_FontMetricsFlags = 2;
pub const SkFontMetrics_FontMetricsFlags_kStrikeoutThicknessIsValid_Flag:
    SkFontMetrics_FontMetricsFlags = 4;
pub const SkFontMetrics_FontMetricsFlags_kStrikeoutPositionIsValid_Flag:
    SkFontMetrics_FontMetricsFlags = 8;
pub type SkFontMetrics_FontMetricsFlags = u32;
#[test]
fn bindgen_test_layout_SkFontMetrics() {
    assert_eq!(
        ::core::mem::size_of::<SkFontMetrics>(),
        64usize,
        concat!("Size of: ", stringify!(SkFontMetrics))
    );
    assert_eq!(
        ::core::mem::align_of::<SkFontMetrics>(),
        4usize,
        concat!("Alignment of ", stringify!(SkFontMetrics))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFontMetrics>())).fFlags as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontMetrics),
            "::",
            stringify!(fFlags)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFontMetrics>())).fTop as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontMetrics),
            "::",
            stringify!(fTop)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFontMetrics>())).fAscent as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontMetrics),
            "::",
            stringify!(fAscent)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFontMetrics>())).fDescent as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontMetrics),
            "::",
            stringify!(fDescent)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFontMetrics>())).fBottom as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontMetrics),
            "::",
            stringify!(fBottom)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFontMetrics>())).fLeading as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontMetrics),
            "::",
            stringify!(fLeading)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFontMetrics>())).fAvgCharWidth as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontMetrics),
            "::",
            stringify!(fAvgCharWidth)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFontMetrics>())).fMaxCharWidth as *const _ as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontMetrics),
            "::",
            stringify!(fMaxCharWidth)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFontMetrics>())).fXMin as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontMetrics),
            "::",
            stringify!(fXMin)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFontMetrics>())).fXMax as *const _ as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontMetrics),
            "::",
            stringify!(fXMax)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFontMetrics>())).fXHeight as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontMetrics),
            "::",
            stringify!(fXHeight)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkFontMetrics>())).fCapHeight as *const _ as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontMetrics),
            "::",
            stringify!(fCapHeight)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkFontMetrics>())).fUnderlineThickness as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontMetrics),
            "::",
            stringify!(fUnderlineThickness)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkFontMetrics>())).fUnderlinePosition as *const _ as usize
        },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontMetrics),
            "::",
            stringify!(fUnderlinePosition)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkFontMetrics>())).fStrikeoutThickness as *const _ as usize
        },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontMetrics),
            "::",
            stringify!(fStrikeoutThickness)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkFontMetrics>())).fStrikeoutPosition as *const _ as usize
        },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(SkFontMetrics),
            "::",
            stringify!(fStrikeoutPosition)
        )
    );
}
#[repr(C)]
pub struct SkFontStyleSet {
    pub _base: SkRefCnt,
}
pub type SkFontStyleSet_INHERITED = SkRefCnt;
#[test]
fn bindgen_test_layout_SkFontStyleSet() {
    assert_eq!(
        ::core::mem::size_of::<SkFontStyleSet>(),
        16usize,
        concat!("Size of: ", stringify!(SkFontStyleSet))
    );
    assert_eq!(
        ::core::mem::align_of::<SkFontStyleSet>(),
        8usize,
        concat!("Alignment of ", stringify!(SkFontStyleSet))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkFontStyleSet11CreateEmptyEv"]
    pub fn SkFontStyleSet_CreateEmpty() -> *mut SkFontStyleSet;
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkFontStyleSet14matchStyleCSS3ERK11SkFontStyle"]
    pub fn SkFontStyleSet_matchStyleCSS3(
        this: *mut SkFontStyleSet,
        pattern: *const SkFontStyle,
    ) -> *mut SkTypeface;
}
impl SkFontStyleSet {
    #[inline]
    pub unsafe fn CreateEmpty() -> *mut SkFontStyleSet {
        SkFontStyleSet_CreateEmpty()
    }
    #[inline]
    pub unsafe fn matchStyleCSS3(&mut self, pattern: *const SkFontStyle) -> *mut SkTypeface {
        SkFontStyleSet_matchStyleCSS3(self, pattern)
    }
}
#[repr(C)]
pub struct SkFontMgr {
    pub _base: SkRefCnt,
}
pub type SkFontMgr_INHERITED = SkRefCnt;
#[test]
fn bindgen_test_layout_SkFontMgr() {
    assert_eq!(
        ::core::mem::size_of::<SkFontMgr>(),
        16usize,
        concat!("Size of: ", stringify!(SkFontMgr))
    );
    assert_eq!(
        ::core::mem::align_of::<SkFontMgr>(),
        8usize,
        concat!("Alignment of ", stringify!(SkFontMgr))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkFontMgr13countFamiliesEv"]
    pub fn SkFontMgr_countFamilies(this: *const SkFontMgr) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkFontMgr13getFamilyNameEiP8SkString"]
    pub fn SkFontMgr_getFamilyName(
        this: *const SkFontMgr,
        index: ::std::os::raw::c_int,
        familyName: *mut SkString,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkFontMgr14createStyleSetEi"]
    pub fn SkFontMgr_createStyleSet(
        this: *const SkFontMgr,
        index: ::std::os::raw::c_int,
    ) -> *mut SkFontStyleSet;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkFontMgr11matchFamilyEPKc"]
    pub fn SkFontMgr_matchFamily(
        this: *const SkFontMgr,
        familyName: *const ::std::os::raw::c_char,
    ) -> *mut SkFontStyleSet;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkFontMgr16matchFamilyStyleEPKcRK11SkFontStyle"]
    pub fn SkFontMgr_matchFamilyStyle(
        this: *const SkFontMgr,
        familyName: *const ::std::os::raw::c_char,
        arg1: *const SkFontStyle,
    ) -> *mut SkTypeface;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkFontMgr25matchFamilyStyleCharacterEPKcRK11SkFontStylePS1_ii"]
    pub fn SkFontMgr_matchFamilyStyleCharacter(
        this: *const SkFontMgr,
        familyName: *const ::std::os::raw::c_char,
        arg1: *const SkFontStyle,
        bcp47: *mut *const ::std::os::raw::c_char,
        bcp47Count: ::std::os::raw::c_int,
        character: SkUnichar,
    ) -> *mut SkTypeface;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkFontMgr14matchFaceStyleEPK10SkTypefaceRK11SkFontStyle"]
    pub fn SkFontMgr_matchFaceStyle(
        this: *const SkFontMgr,
        arg1: *const SkTypeface,
        arg2: *const SkFontStyle,
    ) -> *mut SkTypeface;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkFontMgr12makeFromDataE5sk_spI6SkDataEi"]
    pub fn SkFontMgr_makeFromData(
        this: *const SkFontMgr,
        arg1: sk_sp<SkData>,
        ttcIndex: ::std::os::raw::c_int,
    ) -> sk_sp<SkTypeface>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkFontMgr14makeFromStreamESt10unique_ptrI13SkStreamAssetSt14default_deleteIS1_EEi"]
    pub fn SkFontMgr_makeFromStream(
        this: *const SkFontMgr,
        arg1: u64,
        ttcIndex: ::std::os::raw::c_int,
    ) -> sk_sp<SkTypeface>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkFontMgr14makeFromStreamESt10unique_ptrI13SkStreamAssetSt14default_deleteIS1_EERK15SkFontArguments"]
    pub fn SkFontMgr_makeFromStream1(
        this: *const SkFontMgr,
        arg1: u64,
        arg2: *const SkFontArguments,
    ) -> sk_sp<SkTypeface>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkFontMgr16makeFromFontDataESt10unique_ptrI10SkFontDataSt14default_deleteIS1_EE"]
    pub fn SkFontMgr_makeFromFontData(this: *const SkFontMgr, arg1: u8) -> sk_sp<SkTypeface>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkFontMgr12makeFromFileEPKci"]
    pub fn SkFontMgr_makeFromFile(
        this: *const SkFontMgr,
        path: *const ::std::os::raw::c_char,
        ttcIndex: ::std::os::raw::c_int,
    ) -> sk_sp<SkTypeface>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkFontMgr18legacyMakeTypefaceEPKc11SkFontStyle"]
    pub fn SkFontMgr_legacyMakeTypeface(
        this: *const SkFontMgr,
        familyName: *const ::std::os::raw::c_char,
        style: SkFontStyle,
    ) -> sk_sp<SkTypeface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkFontMgr10RefDefaultEv"]
    pub fn SkFontMgr_RefDefault() -> sk_sp<SkFontMgr>;
}
impl SkFontMgr {
    #[inline]
    pub unsafe fn countFamilies(&self) -> ::std::os::raw::c_int {
        SkFontMgr_countFamilies(self)
    }
    #[inline]
    pub unsafe fn getFamilyName(&self, index: ::std::os::raw::c_int, familyName: *mut SkString) {
        SkFontMgr_getFamilyName(self, index, familyName)
    }
    #[inline]
    pub unsafe fn createStyleSet(&self, index: ::std::os::raw::c_int) -> *mut SkFontStyleSet {
        SkFontMgr_createStyleSet(self, index)
    }
    #[inline]
    pub unsafe fn matchFamily(
        &self,
        familyName: *const ::std::os::raw::c_char,
    ) -> *mut SkFontStyleSet {
        SkFontMgr_matchFamily(self, familyName)
    }
    #[inline]
    pub unsafe fn matchFamilyStyle(
        &self,
        familyName: *const ::std::os::raw::c_char,
        arg1: *const SkFontStyle,
    ) -> *mut SkTypeface {
        SkFontMgr_matchFamilyStyle(self, familyName, arg1)
    }
    #[inline]
    pub unsafe fn matchFamilyStyleCharacter(
        &self,
        familyName: *const ::std::os::raw::c_char,
        arg1: *const SkFontStyle,
        bcp47: *mut *const ::std::os::raw::c_char,
        bcp47Count: ::std::os::raw::c_int,
        character: SkUnichar,
    ) -> *mut SkTypeface {
        SkFontMgr_matchFamilyStyleCharacter(self, familyName, arg1, bcp47, bcp47Count, character)
    }
    #[inline]
    pub unsafe fn matchFaceStyle(
        &self,
        arg1: *const SkTypeface,
        arg2: *const SkFontStyle,
    ) -> *mut SkTypeface {
        SkFontMgr_matchFaceStyle(self, arg1, arg2)
    }
    #[inline]
    pub unsafe fn makeFromData(
        &self,
        arg1: sk_sp<SkData>,
        ttcIndex: ::std::os::raw::c_int,
    ) -> sk_sp<SkTypeface> {
        SkFontMgr_makeFromData(self, arg1, ttcIndex)
    }
    #[inline]
    pub unsafe fn makeFromStream(
        &self,
        arg1: u64,
        ttcIndex: ::std::os::raw::c_int,
    ) -> sk_sp<SkTypeface> {
        SkFontMgr_makeFromStream(self, arg1, ttcIndex)
    }
    #[inline]
    pub unsafe fn makeFromStream1(
        &self,
        arg1: u64,
        arg2: *const SkFontArguments,
    ) -> sk_sp<SkTypeface> {
        SkFontMgr_makeFromStream1(self, arg1, arg2)
    }
    #[inline]
    pub unsafe fn makeFromFontData(&self, arg1: u8) -> sk_sp<SkTypeface> {
        SkFontMgr_makeFromFontData(self, arg1)
    }
    #[inline]
    pub unsafe fn makeFromFile(
        &self,
        path: *const ::std::os::raw::c_char,
        ttcIndex: ::std::os::raw::c_int,
    ) -> sk_sp<SkTypeface> {
        SkFontMgr_makeFromFile(self, path, ttcIndex)
    }
    #[inline]
    pub unsafe fn legacyMakeTypeface(
        &self,
        familyName: *const ::std::os::raw::c_char,
        style: SkFontStyle,
    ) -> sk_sp<SkTypeface> {
        SkFontMgr_legacyMakeTypeface(self, familyName, style)
    }
    #[inline]
    pub unsafe fn RefDefault() -> sk_sp<SkFontMgr> {
        SkFontMgr_RefDefault()
    }
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkFontMgr20onMakeFromStreamArgsESt10unique_ptrI13SkStreamAssetSt14default_deleteIS1_EERK15SkFontArguments"]
    pub fn SkFontMgr_onMakeFromStreamArgs(
        this: *mut ::std::os::raw::c_void,
        arg1: u64,
        arg2: *const SkFontArguments,
    ) -> sk_sp<SkTypeface>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkFontMgr18onMakeFromFontDataESt10unique_ptrI10SkFontDataSt14default_deleteIS1_EE"]
    pub fn SkFontMgr_onMakeFromFontData(
        this: *mut ::std::os::raw::c_void,
        arg1: u8,
    ) -> sk_sp<SkTypeface>;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkGraphics {
    pub _address: u8,
}
pub type SkGraphics_ImageGeneratorFromEncodedDataFactory =
    ::core::option::Option<unsafe extern "C" fn(arg1: sk_sp<SkData>) -> u64>;
#[test]
fn bindgen_test_layout_SkGraphics() {
    assert_eq!(
        ::core::mem::size_of::<SkGraphics>(),
        1usize,
        concat!("Size of: ", stringify!(SkGraphics))
    );
    assert_eq!(
        ::core::mem::align_of::<SkGraphics>(),
        1usize,
        concat!("Alignment of ", stringify!(SkGraphics))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkGraphics4InitEv"]
    pub fn SkGraphics_Init();
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkGraphics17GetFontCacheLimitEv"]
    pub fn SkGraphics_GetFontCacheLimit() -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkGraphics17SetFontCacheLimitEm"]
    pub fn SkGraphics_SetFontCacheLimit(bytes: usize) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkGraphics16GetFontCacheUsedEv"]
    pub fn SkGraphics_GetFontCacheUsed() -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkGraphics21GetFontCacheCountUsedEv"]
    pub fn SkGraphics_GetFontCacheCountUsed() -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkGraphics22GetFontCacheCountLimitEv"]
    pub fn SkGraphics_GetFontCacheCountLimit() -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkGraphics22SetFontCacheCountLimitEi"]
    pub fn SkGraphics_SetFontCacheCountLimit(count: ::std::os::raw::c_int)
        -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkGraphics26GetFontCachePointSizeLimitEv"]
    pub fn SkGraphics_GetFontCachePointSizeLimit() -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkGraphics26SetFontCachePointSizeLimitEi"]
    pub fn SkGraphics_SetFontCachePointSizeLimit(
        maxPointSize: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkGraphics14PurgeFontCacheEv"]
    pub fn SkGraphics_PurgeFontCache();
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkGraphics30GetResourceCacheTotalBytesUsedEv"]
    pub fn SkGraphics_GetResourceCacheTotalBytesUsed() -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkGraphics30GetResourceCacheTotalByteLimitEv"]
    pub fn SkGraphics_GetResourceCacheTotalByteLimit() -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkGraphics30SetResourceCacheTotalByteLimitEm"]
    pub fn SkGraphics_SetResourceCacheTotalByteLimit(newLimit: usize) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkGraphics18PurgeResourceCacheEv"]
    pub fn SkGraphics_PurgeResourceCache();
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkGraphics41GetResourceCacheSingleAllocationByteLimitEv"]
    pub fn SkGraphics_GetResourceCacheSingleAllocationByteLimit() -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkGraphics41SetResourceCacheSingleAllocationByteLimitEm"]
    pub fn SkGraphics_SetResourceCacheSingleAllocationByteLimit(newLimit: usize) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkGraphics20DumpMemoryStatisticsEP17SkTraceMemoryDump"]
    pub fn SkGraphics_DumpMemoryStatistics(dump: *mut SkTraceMemoryDump);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkGraphics14PurgeAllCachesEv"]
    pub fn SkGraphics_PurgeAllCaches();
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkGraphics8SetFlagsEPKc"]
    pub fn SkGraphics_SetFlags(flags: *const ::std::os::raw::c_char);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkGraphics39SetImageGeneratorFromEncodedDataFactoryEPFSt10unique_ptrI16SkImageGeneratorSt14default_deleteIS1_EE5sk_spI6SkDataEE"]
    pub fn SkGraphics_SetImageGeneratorFromEncodedDataFactory(
        arg1: SkGraphics_ImageGeneratorFromEncodedDataFactory,
    ) -> SkGraphics_ImageGeneratorFromEncodedDataFactory;
}
impl SkGraphics {
    #[inline]
    pub unsafe fn Init() {
        SkGraphics_Init()
    }
    #[inline]
    pub unsafe fn GetFontCacheLimit() -> usize {
        SkGraphics_GetFontCacheLimit()
    }
    #[inline]
    pub unsafe fn SetFontCacheLimit(bytes: usize) -> usize {
        SkGraphics_SetFontCacheLimit(bytes)
    }
    #[inline]
    pub unsafe fn GetFontCacheUsed() -> usize {
        SkGraphics_GetFontCacheUsed()
    }
    #[inline]
    pub unsafe fn GetFontCacheCountUsed() -> ::std::os::raw::c_int {
        SkGraphics_GetFontCacheCountUsed()
    }
    #[inline]
    pub unsafe fn GetFontCacheCountLimit() -> ::std::os::raw::c_int {
        SkGraphics_GetFontCacheCountLimit()
    }
    #[inline]
    pub unsafe fn SetFontCacheCountLimit(count: ::std::os::raw::c_int) -> ::std::os::raw::c_int {
        SkGraphics_SetFontCacheCountLimit(count)
    }
    #[inline]
    pub unsafe fn GetFontCachePointSizeLimit() -> ::std::os::raw::c_int {
        SkGraphics_GetFontCachePointSizeLimit()
    }
    #[inline]
    pub unsafe fn SetFontCachePointSizeLimit(
        maxPointSize: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int {
        SkGraphics_SetFontCachePointSizeLimit(maxPointSize)
    }
    #[inline]
    pub unsafe fn PurgeFontCache() {
        SkGraphics_PurgeFontCache()
    }
    #[inline]
    pub unsafe fn GetResourceCacheTotalBytesUsed() -> usize {
        SkGraphics_GetResourceCacheTotalBytesUsed()
    }
    #[inline]
    pub unsafe fn GetResourceCacheTotalByteLimit() -> usize {
        SkGraphics_GetResourceCacheTotalByteLimit()
    }
    #[inline]
    pub unsafe fn SetResourceCacheTotalByteLimit(newLimit: usize) -> usize {
        SkGraphics_SetResourceCacheTotalByteLimit(newLimit)
    }
    #[inline]
    pub unsafe fn PurgeResourceCache() {
        SkGraphics_PurgeResourceCache()
    }
    #[inline]
    pub unsafe fn GetResourceCacheSingleAllocationByteLimit() -> usize {
        SkGraphics_GetResourceCacheSingleAllocationByteLimit()
    }
    #[inline]
    pub unsafe fn SetResourceCacheSingleAllocationByteLimit(newLimit: usize) -> usize {
        SkGraphics_SetResourceCacheSingleAllocationByteLimit(newLimit)
    }
    #[inline]
    pub unsafe fn DumpMemoryStatistics(dump: *mut SkTraceMemoryDump) {
        SkGraphics_DumpMemoryStatistics(dump)
    }
    #[inline]
    pub unsafe fn PurgeAllCaches() {
        SkGraphics_PurgeAllCaches()
    }
    #[inline]
    pub unsafe fn SetFlags(flags: *const ::std::os::raw::c_char) {
        SkGraphics_SetFlags(flags)
    }
    #[inline]
    pub unsafe fn SetImageGeneratorFromEncodedDataFactory(
        arg1: SkGraphics_ImageGeneratorFromEncodedDataFactory,
    ) -> SkGraphics_ImageGeneratorFromEncodedDataFactory {
        SkGraphics_SetImageGeneratorFromEncodedDataFactory(arg1)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkSpecialImage {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkImageFilterCache {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkImageFilterCacheKey {
    _unused: [u8; 0],
}
#[repr(C)]
pub struct SkImageFilter {
    pub _base: SkFlattenable,
    pub fInputs: [u64; 4usize],
    pub fUsesSrcInput: bool,
    pub fCropRect: SkImageFilter_CropRect,
    pub fUniqueID: u32,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkImageFilter_OutputProperties {
    pub fColorType: SkColorType,
    pub fColorSpace: *mut SkColorSpace,
}
#[test]
fn bindgen_test_layout_SkImageFilter_OutputProperties() {
    assert_eq!(
        ::core::mem::size_of::<SkImageFilter_OutputProperties>(),
        16usize,
        concat!("Size of: ", stringify!(SkImageFilter_OutputProperties))
    );
    assert_eq!(
        ::core::mem::align_of::<SkImageFilter_OutputProperties>(),
        8usize,
        concat!("Alignment of ", stringify!(SkImageFilter_OutputProperties))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkImageFilter_OutputProperties>())).fColorType as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImageFilter_OutputProperties),
            "::",
            stringify!(fColorType)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkImageFilter_OutputProperties>())).fColorSpace as *const _
                as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImageFilter_OutputProperties),
            "::",
            stringify!(fColorSpace)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkImageFilter_Context {
    pub fCTM: SkMatrix,
    pub fClipBounds: SkIRect,
    pub fCache: *mut SkImageFilterCache,
    pub fOutputProperties: SkImageFilter_OutputProperties,
}
#[test]
fn bindgen_test_layout_SkImageFilter_Context() {
    assert_eq!(
        ::core::mem::size_of::<SkImageFilter_Context>(),
        80usize,
        concat!("Size of: ", stringify!(SkImageFilter_Context))
    );
    assert_eq!(
        ::core::mem::align_of::<SkImageFilter_Context>(),
        8usize,
        concat!("Alignment of ", stringify!(SkImageFilter_Context))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkImageFilter_Context>())).fCTM as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImageFilter_Context),
            "::",
            stringify!(fCTM)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkImageFilter_Context>())).fClipBounds as *const _ as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImageFilter_Context),
            "::",
            stringify!(fClipBounds)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkImageFilter_Context>())).fCache as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImageFilter_Context),
            "::",
            stringify!(fCache)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkImageFilter_Context>())).fOutputProperties as *const _
                as usize
        },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImageFilter_Context),
            "::",
            stringify!(fOutputProperties)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkImageFilter_CropRect {
    pub fRect: SkRect,
    pub fFlags: u32,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkImageFilter_CropRect_CropEdge {
    kHasLeft_CropEdge = 1,
    kHasTop_CropEdge = 2,
    kHasWidth_CropEdge = 4,
    kHasHeight_CropEdge = 8,
    kHasAll_CropEdge = 15,
}
#[test]
fn bindgen_test_layout_SkImageFilter_CropRect() {
    assert_eq!(
        ::core::mem::size_of::<SkImageFilter_CropRect>(),
        20usize,
        concat!("Size of: ", stringify!(SkImageFilter_CropRect))
    );
    assert_eq!(
        ::core::mem::align_of::<SkImageFilter_CropRect>(),
        4usize,
        concat!("Alignment of ", stringify!(SkImageFilter_CropRect))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkImageFilter_CropRect>())).fRect as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImageFilter_CropRect),
            "::",
            stringify!(fRect)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkImageFilter_CropRect>())).fFlags as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImageFilter_CropRect),
            "::",
            stringify!(fFlags)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkImageFilter8CropRect7applyToERK7SkIRectRK8SkMatrixbPS1_"]
    pub fn SkImageFilter_CropRect_applyTo(
        this: *const SkImageFilter_CropRect,
        imageBounds: *const SkIRect,
        matrix: *const SkMatrix,
        embiggen: bool,
        cropped: *mut SkIRect,
    );
}
impl SkImageFilter_CropRect {
    #[inline]
    pub unsafe fn applyTo(
        &self,
        imageBounds: *const SkIRect,
        matrix: *const SkMatrix,
        embiggen: bool,
        cropped: *mut SkIRect,
    ) {
        SkImageFilter_CropRect_applyTo(self, imageBounds, matrix, embiggen, cropped)
    }
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkImageFilter_TileUsage {
    kPossible_TileUsage = 0,
    kNever_TileUsage = 1,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkImageFilter_MapDirection {
    kForward_MapDirection = 0,
    kReverse_MapDirection = 1,
}
#[repr(C)]
pub struct SkImageFilter_Common {
    pub fCropRect: SkImageFilter_CropRect,
    pub fInputs: [u64; 5usize],
}
#[test]
fn bindgen_test_layout_SkImageFilter_Common() {
    assert_eq!(
        ::core::mem::size_of::<SkImageFilter_Common>(),
        64usize,
        concat!("Size of: ", stringify!(SkImageFilter_Common))
    );
    assert_eq!(
        ::core::mem::align_of::<SkImageFilter_Common>(),
        8usize,
        concat!("Alignment of ", stringify!(SkImageFilter_Common))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkImageFilter_Common>())).fCropRect as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImageFilter_Common),
            "::",
            stringify!(fCropRect)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkImageFilter_Common>())).fInputs as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImageFilter_Common),
            "::",
            stringify!(fInputs)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkImageFilter6Common9unflattenER12SkReadBufferi"]
    pub fn SkImageFilter_Common_unflatten(
        this: *mut SkImageFilter_Common,
        arg1: *mut SkReadBuffer,
        expectedInputs: ::std::os::raw::c_int,
    ) -> bool;
}
impl SkImageFilter_Common {
    #[inline]
    pub unsafe fn unflatten(
        &mut self,
        arg1: *mut SkReadBuffer,
        expectedInputs: ::std::os::raw::c_int,
    ) -> bool {
        SkImageFilter_Common_unflatten(self, arg1, expectedInputs)
    }
}
pub type SkImageFilter_INHERITED = SkFlattenable;
#[test]
fn bindgen_test_layout_SkImageFilter() {
    assert_eq!(
        ::core::mem::size_of::<SkImageFilter>(),
        80usize,
        concat!("Size of: ", stringify!(SkImageFilter))
    );
    assert_eq!(
        ::core::mem::align_of::<SkImageFilter>(),
        8usize,
        concat!("Alignment of ", stringify!(SkImageFilter))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkImageFilter>())).fInputs as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImageFilter),
            "::",
            stringify!(fInputs)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkImageFilter>())).fUsesSrcInput as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImageFilter),
            "::",
            stringify!(fUsesSrcInput)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkImageFilter>())).fCropRect as *const _ as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImageFilter),
            "::",
            stringify!(fCropRect)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkImageFilter>())).fUniqueID as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImageFilter),
            "::",
            stringify!(fUniqueID)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkImageFilter11filterImageEP14SkSpecialImageRKNS_7ContextEP8SkIPoint"]
    pub fn SkImageFilter_filterImage(
        this: *const SkImageFilter,
        src: *mut SkSpecialImage,
        context: *const SkImageFilter_Context,
        offset: *mut SkIPoint,
    ) -> sk_sp<SkSpecialImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkImageFilter12filterBoundsERK7SkIRectRK8SkMatrixNS_12MapDirectionEPS1_"]
    pub fn SkImageFilter_filterBounds(
        this: *const SkImageFilter,
        src: *const SkIRect,
        ctm: *const SkMatrix,
        arg1: SkImageFilter_MapDirection,
        inputRect: *const SkIRect,
    ) -> SkIRect;
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkImageFilter10DrawWithFPEP18GrRecordingContextSt10unique_ptrI19GrFragmentProcessorSt14default_deleteIS3_EERK7SkIRectRKNS_16OutputPropertiesE11GrProtected"]
    pub fn SkImageFilter_DrawWithFP(
        context: *mut GrRecordingContext,
        fp: u8,
        bounds: *const SkIRect,
        outputProperties: *const SkImageFilter_OutputProperties,
        isProtected: GrProtected,
    ) -> sk_sp<SkSpecialImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkImageFilter9removeKeyERK21SkImageFilterCacheKey"]
    pub fn SkImageFilter_removeKey(this: *const SkImageFilter, key: *const SkImageFilterCacheKey);
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkImageFilter14asAColorFilterEPP13SkColorFilter"]
    pub fn SkImageFilter_asAColorFilter(
        this: *const SkImageFilter,
        filterPtr: *mut *mut SkColorFilter,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkImageFilter20canComputeFastBoundsEv"]
    pub fn SkImageFilter_canComputeFastBounds(this: *const SkImageFilter) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkImageFilter19makeWithLocalMatrixERK8SkMatrix"]
    pub fn SkImageFilter_makeWithLocalMatrix(
        this: *const SkImageFilter,
        matrix: *const SkMatrix,
    ) -> sk_sp<SkImageFilter>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkImageFilter19canHandleComplexCTMEv"]
    pub fn SkImageFilter_canHandleComplexCTM(this: *const SkImageFilter) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkImageFilter16MakeMatrixFilterERK8SkMatrix15SkFilterQuality5sk_spIS_E"]
    pub fn SkImageFilter_MakeMatrixFilter(
        matrix: *const SkMatrix,
        quality: SkFilterQuality,
        input: sk_sp<SkImageFilter>,
    ) -> sk_sp<SkImageFilter>;
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkImageFilter20RegisterFlattenablesEv"]
    pub fn SkImageFilter_RegisterFlattenables();
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkImageFilter11filterInputEiP14SkSpecialImageRKNS_7ContextEP8SkIPoint"]
    pub fn SkImageFilter_filterInput(
        this: *const SkImageFilter,
        index: ::std::os::raw::c_int,
        src: *mut SkSpecialImage,
        arg1: *const SkImageFilter_Context,
        offset: *mut SkIPoint,
    ) -> sk_sp<SkSpecialImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkImageFilter13applyCropRectERKNS_7ContextERK7SkIRectPS3_"]
    pub fn SkImageFilter_applyCropRect(
        this: *const SkImageFilter,
        arg1: *const SkImageFilter_Context,
        srcBounds: *const SkIRect,
        dstBounds: *mut SkIRect,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkImageFilter19applyCropRectAndPadERKNS_7ContextEP14SkSpecialImageP8SkIPointP7SkIRect"]
    pub fn SkImageFilter_applyCropRectAndPad(
        this: *const SkImageFilter,
        arg1: *const SkImageFilter_Context,
        src: *mut SkSpecialImage,
        srcOffset: *mut SkIPoint,
        bounds: *mut SkIRect,
    ) -> sk_sp<SkSpecialImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkImageFilter10mapContextERKNS_7ContextE"]
    pub fn SkImageFilter_mapContext(
        this: *const SkImageFilter,
        ctx: *const SkImageFilter_Context,
    ) -> SkImageFilter_Context;
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkImageFilter17ImageToColorSpaceEP14SkSpecialImageRKNS_16OutputPropertiesE"]
    pub fn SkImageFilter_ImageToColorSpace(
        src: *mut SkSpecialImage,
        arg1: *const SkImageFilter_OutputProperties,
    ) -> sk_sp<SkSpecialImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkImageFilter25DetermineRepeatedSrcBoundERK7SkIRectRK8SkIPointRK7SkISizeS2_"]
    pub fn SkImageFilter_DetermineRepeatedSrcBound(
        srcBounds: *const SkIRect,
        filterOffset: *const SkIVector,
        filterSize: *const SkISize,
        originalSrcBounds: *const SkIRect,
    ) -> SkIRect;
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkImageFilterC2EPK5sk_spIS_EiPKNS_8CropRectE"]
    pub fn SkImageFilter_SkImageFilter(
        this: *mut SkImageFilter,
        inputs: *const sk_sp<SkImageFilter>,
        inputCount: ::std::os::raw::c_int,
        cropRect: *const SkImageFilter_CropRect,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkImageFilterC2EiR12SkReadBuffer"]
    pub fn SkImageFilter_SkImageFilter1(
        this: *mut SkImageFilter,
        inputCount: ::std::os::raw::c_int,
        rb: *mut SkReadBuffer,
    );
}
impl SkImageFilter {
    #[inline]
    pub unsafe fn filterImage(
        &self,
        src: *mut SkSpecialImage,
        context: *const SkImageFilter_Context,
        offset: *mut SkIPoint,
    ) -> sk_sp<SkSpecialImage> {
        SkImageFilter_filterImage(self, src, context, offset)
    }
    #[inline]
    pub unsafe fn filterBounds(
        &self,
        src: *const SkIRect,
        ctm: *const SkMatrix,
        arg1: SkImageFilter_MapDirection,
        inputRect: *const SkIRect,
    ) -> SkIRect {
        SkImageFilter_filterBounds(self, src, ctm, arg1, inputRect)
    }
    #[inline]
    pub unsafe fn DrawWithFP(
        context: *mut GrRecordingContext,
        fp: u8,
        bounds: *const SkIRect,
        outputProperties: *const SkImageFilter_OutputProperties,
        isProtected: GrProtected,
    ) -> sk_sp<SkSpecialImage> {
        SkImageFilter_DrawWithFP(context, fp, bounds, outputProperties, isProtected)
    }
    #[inline]
    pub unsafe fn removeKey(&self, key: *const SkImageFilterCacheKey) {
        SkImageFilter_removeKey(self, key)
    }
    #[inline]
    pub unsafe fn asAColorFilter(&self, filterPtr: *mut *mut SkColorFilter) -> bool {
        SkImageFilter_asAColorFilter(self, filterPtr)
    }
    #[inline]
    pub unsafe fn canComputeFastBounds(&self) -> bool {
        SkImageFilter_canComputeFastBounds(self)
    }
    #[inline]
    pub unsafe fn makeWithLocalMatrix(&self, matrix: *const SkMatrix) -> sk_sp<SkImageFilter> {
        SkImageFilter_makeWithLocalMatrix(self, matrix)
    }
    #[inline]
    pub unsafe fn canHandleComplexCTM(&self) -> bool {
        SkImageFilter_canHandleComplexCTM(self)
    }
    #[inline]
    pub unsafe fn MakeMatrixFilter(
        matrix: *const SkMatrix,
        quality: SkFilterQuality,
        input: sk_sp<SkImageFilter>,
    ) -> sk_sp<SkImageFilter> {
        SkImageFilter_MakeMatrixFilter(matrix, quality, input)
    }
    #[inline]
    pub unsafe fn RegisterFlattenables() {
        SkImageFilter_RegisterFlattenables()
    }
    #[inline]
    pub unsafe fn filterInput(
        &self,
        index: ::std::os::raw::c_int,
        src: *mut SkSpecialImage,
        arg1: *const SkImageFilter_Context,
        offset: *mut SkIPoint,
    ) -> sk_sp<SkSpecialImage> {
        SkImageFilter_filterInput(self, index, src, arg1, offset)
    }
    #[inline]
    pub unsafe fn applyCropRect(
        &self,
        arg1: *const SkImageFilter_Context,
        srcBounds: *const SkIRect,
        dstBounds: *mut SkIRect,
    ) -> bool {
        SkImageFilter_applyCropRect(self, arg1, srcBounds, dstBounds)
    }
    #[inline]
    pub unsafe fn applyCropRectAndPad(
        &self,
        arg1: *const SkImageFilter_Context,
        src: *mut SkSpecialImage,
        srcOffset: *mut SkIPoint,
        bounds: *mut SkIRect,
    ) -> sk_sp<SkSpecialImage> {
        SkImageFilter_applyCropRectAndPad(self, arg1, src, srcOffset, bounds)
    }
    #[inline]
    pub unsafe fn mapContext(&self, ctx: *const SkImageFilter_Context) -> SkImageFilter_Context {
        SkImageFilter_mapContext(self, ctx)
    }
    #[inline]
    pub unsafe fn ImageToColorSpace(
        src: *mut SkSpecialImage,
        arg1: *const SkImageFilter_OutputProperties,
    ) -> sk_sp<SkSpecialImage> {
        SkImageFilter_ImageToColorSpace(src, arg1)
    }
    #[inline]
    pub unsafe fn DetermineRepeatedSrcBound(
        srcBounds: *const SkIRect,
        filterOffset: *const SkIVector,
        filterSize: *const SkISize,
        originalSrcBounds: *const SkIRect,
    ) -> SkIRect {
        SkImageFilter_DetermineRepeatedSrcBound(
            srcBounds,
            filterOffset,
            filterSize,
            originalSrcBounds,
        )
    }
    #[inline]
    pub unsafe fn new(
        inputs: *const sk_sp<SkImageFilter>,
        inputCount: ::std::os::raw::c_int,
        cropRect: *const SkImageFilter_CropRect,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkImageFilter_SkImageFilter(&mut __bindgen_tmp, inputs, inputCount, cropRect);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(inputCount: ::std::os::raw::c_int, rb: *mut SkReadBuffer) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkImageFilter_SkImageFilter1(&mut __bindgen_tmp, inputCount, rb);
        __bindgen_tmp
    }
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkImageFilter17computeFastBoundsERK6SkRect"]
    pub fn SkImageFilter_computeFastBounds(
        this: *mut ::std::os::raw::c_void,
        bounds: *const SkRect,
    ) -> SkRect;
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkImageFilterD1Ev"]
    pub fn SkImageFilter_SkImageFilter_destructor(this: *mut SkImageFilter);
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkImageFilter7flattenER13SkWriteBuffer"]
    pub fn SkImageFilter_flatten(this: *mut ::std::os::raw::c_void, arg1: *mut SkWriteBuffer);
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkImageFilter14onFilterBoundsERK7SkIRectRK8SkMatrixNS_12MapDirectionEPS1_"]
    pub fn SkImageFilter_onFilterBounds(
        this: *mut ::std::os::raw::c_void,
        arg1: *const SkIRect,
        ctm: *const SkMatrix,
        arg2: SkImageFilter_MapDirection,
        inputRect: *const SkIRect,
    ) -> SkIRect;
}
extern "C" {
    #[link_name = "\u{1}_ZNK13SkImageFilter18onFilterNodeBoundsERK7SkIRectRK8SkMatrixNS_12MapDirectionEPS1_"]
    pub fn SkImageFilter_onFilterNodeBounds(
        this: *mut ::std::os::raw::c_void,
        arg1: *const SkIRect,
        ctm: *const SkMatrix,
        arg2: SkImageFilter_MapDirection,
        inputRect: *const SkIRect,
    ) -> SkIRect;
}
impl SkColorChannel {
    pub const kLastEnum: SkColorChannel = SkColorChannel::kA;
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkColorChannel {
    kR = 0,
    kG = 1,
    kB = 2,
    kA = 3,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkYUVAIndex {
    pub fIndex: ::std::os::raw::c_int,
    pub fChannel: SkColorChannel,
}
impl SkYUVAIndex_Index {
    pub const kLast_Index: SkYUVAIndex_Index = SkYUVAIndex_Index::kA_Index;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkYUVAIndex_Index {
    kY_Index = 0,
    kU_Index = 1,
    kV_Index = 2,
    kA_Index = 3,
}
pub const SkYUVAIndex_kIndexCount: ::std::os::raw::c_int = 4;
#[test]
fn bindgen_test_layout_SkYUVAIndex() {
    assert_eq!(
        ::core::mem::size_of::<SkYUVAIndex>(),
        8usize,
        concat!("Size of: ", stringify!(SkYUVAIndex))
    );
    assert_eq!(
        ::core::mem::align_of::<SkYUVAIndex>(),
        4usize,
        concat!("Alignment of ", stringify!(SkYUVAIndex))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkYUVAIndex>())).fIndex as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkYUVAIndex),
            "::",
            stringify!(fIndex)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkYUVAIndex>())).fChannel as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkYUVAIndex),
            "::",
            stringify!(fChannel)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkYUVASizeInfo {
    pub fSizes: [SkISize; 4usize],
    pub fWidthBytes: [usize; 4usize],
    pub fOrigin: SkEncodedOrigin,
}
pub const SkYUVASizeInfo_kMaxCount: ::std::os::raw::c_int = 4;
#[test]
fn bindgen_test_layout_SkYUVASizeInfo() {
    assert_eq!(
        ::core::mem::size_of::<SkYUVASizeInfo>(),
        72usize,
        concat!("Size of: ", stringify!(SkYUVASizeInfo))
    );
    assert_eq!(
        ::core::mem::align_of::<SkYUVASizeInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(SkYUVASizeInfo))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkYUVASizeInfo>())).fSizes as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkYUVASizeInfo),
            "::",
            stringify!(fSizes)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkYUVASizeInfo>())).fWidthBytes as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(SkYUVASizeInfo),
            "::",
            stringify!(fWidthBytes)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkYUVASizeInfo>())).fOrigin as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(SkYUVASizeInfo),
            "::",
            stringify!(fOrigin)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK14SkYUVASizeInfo13computePlanesEPvPS0_"]
    pub fn SkYUVASizeInfo_computePlanes(
        this: *const SkYUVASizeInfo,
        base: *mut ::std::os::raw::c_void,
        planes: *mut *mut ::std::os::raw::c_void,
    );
}
impl SkYUVASizeInfo {
    #[inline]
    pub unsafe fn computePlanes(
        &self,
        base: *mut ::std::os::raw::c_void,
        planes: *mut *mut ::std::os::raw::c_void,
    ) {
        SkYUVASizeInfo_computePlanes(self, base, planes)
    }
}
#[repr(C)]
pub struct SkImageGenerator__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
pub struct SkImageGenerator {
    pub vtable_: *const SkImageGenerator__bindgen_vtable,
    pub fInfo: SkImageInfo,
    pub fUniqueID: u32,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkImageGenerator_Options {
    pub _address: u8,
}
#[test]
fn bindgen_test_layout_SkImageGenerator_Options() {
    assert_eq!(
        ::core::mem::size_of::<SkImageGenerator_Options>(),
        1usize,
        concat!("Size of: ", stringify!(SkImageGenerator_Options))
    );
    assert_eq!(
        ::core::mem::align_of::<SkImageGenerator_Options>(),
        1usize,
        concat!("Alignment of ", stringify!(SkImageGenerator_Options))
    );
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkImageGenerator_TexGenType {
    kNone = 0,
    kCheap = 1,
    kExpensive = 2,
}
pub const SkImageGenerator_kNeedNewImageUniqueID: ::std::os::raw::c_int = 0;
#[test]
fn bindgen_test_layout_SkImageGenerator() {
    assert_eq!(
        ::core::mem::size_of::<SkImageGenerator>(),
        40usize,
        concat!("Size of: ", stringify!(SkImageGenerator))
    );
    assert_eq!(
        ::core::mem::align_of::<SkImageGenerator>(),
        8usize,
        concat!("Alignment of ", stringify!(SkImageGenerator))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkImageGenerator>())).fInfo as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImageGenerator),
            "::",
            stringify!(fInfo)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkImageGenerator>())).fUniqueID as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(SkImageGenerator),
            "::",
            stringify!(fUniqueID)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN16SkImageGenerator9getPixelsERK11SkImageInfoPvm"]
    pub fn SkImageGenerator_getPixels(
        this: *mut SkImageGenerator,
        info: *const SkImageInfo,
        pixels: *mut ::std::os::raw::c_void,
        rowBytes: usize,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK16SkImageGenerator10queryYUVA8EP14SkYUVASizeInfoP11SkYUVAIndexP15SkYUVColorSpace"]
    pub fn SkImageGenerator_queryYUVA8(
        this: *const SkImageGenerator,
        sizeInfo: *mut SkYUVASizeInfo,
        yuvaIndices: *mut SkYUVAIndex,
        colorSpace: *mut SkYUVColorSpace,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN16SkImageGenerator14getYUVA8PlanesERK14SkYUVASizeInfoPK11SkYUVAIndexPPv"]
    pub fn SkImageGenerator_getYUVA8Planes(
        this: *mut SkImageGenerator,
        sizeInfo: *const SkYUVASizeInfo,
        yuvaIndices: *const SkYUVAIndex,
        planes: *mut *mut ::std::os::raw::c_void,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN16SkImageGenerator15generateTextureEP18GrRecordingContextRK11SkImageInfoRK8SkIPointb"]
    pub fn SkImageGenerator_generateTexture(
        this: *mut SkImageGenerator,
        arg1: *mut GrRecordingContext,
        info: *const SkImageInfo,
        origin: *const SkIPoint,
        willNeedMipMaps: bool,
    ) -> sk_sp<GrTextureProxy>;
}
extern "C" {
    #[link_name = "\u{1}_ZN16SkImageGenerator15MakeFromEncodedE5sk_spI6SkDataE"]
    pub fn SkImageGenerator_MakeFromEncoded(arg1: sk_sp<SkData>) -> u64;
}
extern "C" {
    #[link_name = "\u{1}_ZN16SkImageGenerator15MakeFromPictureERK7SkISize5sk_spI9SkPictureEPK8SkMatrixPK7SkPaintN7SkImage8BitDepthES3_I12SkColorSpaceE"]
    pub fn SkImageGenerator_MakeFromPicture(
        arg1: *const SkISize,
        arg2: sk_sp<SkPicture>,
        arg3: *const SkMatrix,
        arg4: *const SkPaint,
        arg5: SkImage_BitDepth,
        arg6: sk_sp<SkColorSpace>,
    ) -> u64;
}
extern "C" {
    #[link_name = "\u{1}_ZN16SkImageGeneratorC1ERK11SkImageInfoj"]
    pub fn SkImageGenerator_SkImageGenerator(
        this: *mut SkImageGenerator,
        info: *const SkImageInfo,
        uniqueId: u32,
    );
}
impl SkImageGenerator {
    #[inline]
    pub unsafe fn getPixels(
        &mut self,
        info: *const SkImageInfo,
        pixels: *mut ::std::os::raw::c_void,
        rowBytes: usize,
    ) -> bool {
        SkImageGenerator_getPixels(self, info, pixels, rowBytes)
    }
    #[inline]
    pub unsafe fn queryYUVA8(
        &self,
        sizeInfo: *mut SkYUVASizeInfo,
        yuvaIndices: *mut SkYUVAIndex,
        colorSpace: *mut SkYUVColorSpace,
    ) -> bool {
        SkImageGenerator_queryYUVA8(self, sizeInfo, yuvaIndices, colorSpace)
    }
    #[inline]
    pub unsafe fn getYUVA8Planes(
        &mut self,
        sizeInfo: *const SkYUVASizeInfo,
        yuvaIndices: *const SkYUVAIndex,
        planes: *mut *mut ::std::os::raw::c_void,
    ) -> bool {
        SkImageGenerator_getYUVA8Planes(self, sizeInfo, yuvaIndices, planes)
    }
    #[inline]
    pub unsafe fn generateTexture(
        &mut self,
        arg1: *mut GrRecordingContext,
        info: *const SkImageInfo,
        origin: *const SkIPoint,
        willNeedMipMaps: bool,
    ) -> sk_sp<GrTextureProxy> {
        SkImageGenerator_generateTexture(self, arg1, info, origin, willNeedMipMaps)
    }
    #[inline]
    pub unsafe fn MakeFromEncoded(arg1: sk_sp<SkData>) -> u64 {
        SkImageGenerator_MakeFromEncoded(arg1)
    }
    #[inline]
    pub unsafe fn MakeFromPicture(
        arg1: *const SkISize,
        arg2: sk_sp<SkPicture>,
        arg3: *const SkMatrix,
        arg4: *const SkPaint,
        arg5: SkImage_BitDepth,
        arg6: sk_sp<SkColorSpace>,
    ) -> u64 {
        SkImageGenerator_MakeFromPicture(arg1, arg2, arg3, arg4, arg5, arg6)
    }
    #[inline]
    pub unsafe fn new(info: *const SkImageInfo, uniqueId: u32) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkImageGenerator_SkImageGenerator(&mut __bindgen_tmp, info, uniqueId);
        __bindgen_tmp
    }
}
extern "C" {
    #[link_name = "\u{1}_ZN16SkImageGenerator17onGenerateTextureEP18GrRecordingContextRK11SkImageInfoRK8SkIPointb"]
    pub fn SkImageGenerator_onGenerateTexture(
        this: *mut ::std::os::raw::c_void,
        arg1: *mut GrRecordingContext,
        arg2: *const SkImageInfo,
        arg3: *const SkIPoint,
        willNeedMipMaps: bool,
    ) -> sk_sp<GrTextureProxy>;
}
impl SkCoverageMode {
    pub const kLast: SkCoverageMode = SkCoverageMode::kXor;
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkCoverageMode {
    kUnion = 0,
    kIntersect = 1,
    kDifference = 2,
    kReverseDifference = 3,
    kXor = 4,
}
#[repr(C)]
pub struct SkMaskFilter {
    pub _base: SkFlattenable,
}
#[test]
fn bindgen_test_layout_SkMaskFilter() {
    assert_eq!(
        ::core::mem::size_of::<SkMaskFilter>(),
        16usize,
        concat!("Size of: ", stringify!(SkMaskFilter))
    );
    assert_eq!(
        ::core::mem::align_of::<SkMaskFilter>(),
        8usize,
        concat!("Alignment of ", stringify!(SkMaskFilter))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN12SkMaskFilter8MakeBlurE11SkBlurStylefb"]
    pub fn SkMaskFilter_MakeBlur(
        style: SkBlurStyle,
        sigma: SkScalar,
        respectCTM: bool,
    ) -> sk_sp<SkMaskFilter>;
}
extern "C" {
    #[link_name = "\u{1}_ZN12SkMaskFilter11MakeComposeE5sk_spIS_ES1_"]
    pub fn SkMaskFilter_MakeCompose(
        outer: sk_sp<SkMaskFilter>,
        inner: sk_sp<SkMaskFilter>,
    ) -> sk_sp<SkMaskFilter>;
}
extern "C" {
    #[link_name = "\u{1}_ZN12SkMaskFilter11MakeCombineE5sk_spIS_ES1_14SkCoverageMode"]
    pub fn SkMaskFilter_MakeCombine(
        filterA: sk_sp<SkMaskFilter>,
        filterB: sk_sp<SkMaskFilter>,
        mode: SkCoverageMode,
    ) -> sk_sp<SkMaskFilter>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK12SkMaskFilter14makeWithMatrixERK8SkMatrix"]
    pub fn SkMaskFilter_makeWithMatrix(
        this: *const SkMaskFilter,
        arg1: *const SkMatrix,
    ) -> sk_sp<SkMaskFilter>;
}
impl SkMaskFilter {
    #[inline]
    pub unsafe fn MakeBlur(
        style: SkBlurStyle,
        sigma: SkScalar,
        respectCTM: bool,
    ) -> sk_sp<SkMaskFilter> {
        SkMaskFilter_MakeBlur(style, sigma, respectCTM)
    }
    #[inline]
    pub unsafe fn MakeCompose(
        outer: sk_sp<SkMaskFilter>,
        inner: sk_sp<SkMaskFilter>,
    ) -> sk_sp<SkMaskFilter> {
        SkMaskFilter_MakeCompose(outer, inner)
    }
    #[inline]
    pub unsafe fn MakeCombine(
        filterA: sk_sp<SkMaskFilter>,
        filterB: sk_sp<SkMaskFilter>,
        mode: SkCoverageMode,
    ) -> sk_sp<SkMaskFilter> {
        SkMaskFilter_MakeCombine(filterA, filterB, mode)
    }
    #[inline]
    pub unsafe fn makeWithMatrix(&self, arg1: *const SkMatrix) -> sk_sp<SkMaskFilter> {
        SkMaskFilter_makeWithMatrix(self, arg1)
    }
}
#[repr(C)]
pub struct SkMultiPictureDraw {
    pub fThreadSafeDrawData: SkTDArray<SkMultiPictureDraw_DrawData>,
    pub fGPUDrawData: SkTDArray<SkMultiPictureDraw_DrawData>,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkMultiPictureDraw_DrawData {
    pub fCanvas: *mut SkCanvas,
    pub fPicture: *const SkPicture,
    pub fMatrix: SkMatrix,
    pub fPaint: *mut SkPaint,
}
#[test]
fn bindgen_test_layout_SkMultiPictureDraw_DrawData() {
    assert_eq!(
        ::core::mem::size_of::<SkMultiPictureDraw_DrawData>(),
        64usize,
        concat!("Size of: ", stringify!(SkMultiPictureDraw_DrawData))
    );
    assert_eq!(
        ::core::mem::align_of::<SkMultiPictureDraw_DrawData>(),
        8usize,
        concat!("Alignment of ", stringify!(SkMultiPictureDraw_DrawData))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkMultiPictureDraw_DrawData>())).fCanvas as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkMultiPictureDraw_DrawData),
            "::",
            stringify!(fCanvas)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkMultiPictureDraw_DrawData>())).fPicture as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkMultiPictureDraw_DrawData),
            "::",
            stringify!(fPicture)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkMultiPictureDraw_DrawData>())).fMatrix as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkMultiPictureDraw_DrawData),
            "::",
            stringify!(fMatrix)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkMultiPictureDraw_DrawData>())).fPaint as *const _ as usize
        },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(SkMultiPictureDraw_DrawData),
            "::",
            stringify!(fPaint)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN18SkMultiPictureDraw8DrawData4initEP8SkCanvasPK9SkPicturePK8SkMatrixPK7SkPaint"]
    pub fn SkMultiPictureDraw_DrawData_init(
        this: *mut SkMultiPictureDraw_DrawData,
        arg1: *mut SkCanvas,
        arg2: *const SkPicture,
        arg3: *const SkMatrix,
        arg4: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN18SkMultiPictureDraw8DrawData4drawEv"]
    pub fn SkMultiPictureDraw_DrawData_draw(this: *mut SkMultiPictureDraw_DrawData);
}
extern "C" {
    #[link_name = "\u{1}_ZN18SkMultiPictureDraw8DrawData5ResetER9SkTDArrayIS0_E"]
    pub fn SkMultiPictureDraw_DrawData_Reset(arg1: *mut SkTDArray<SkMultiPictureDraw_DrawData>);
}
impl SkMultiPictureDraw_DrawData {
    #[inline]
    pub unsafe fn init(
        &mut self,
        arg1: *mut SkCanvas,
        arg2: *const SkPicture,
        arg3: *const SkMatrix,
        arg4: *const SkPaint,
    ) {
        SkMultiPictureDraw_DrawData_init(self, arg1, arg2, arg3, arg4)
    }
    #[inline]
    pub unsafe fn draw(&mut self) {
        SkMultiPictureDraw_DrawData_draw(self)
    }
    #[inline]
    pub unsafe fn Reset(arg1: *mut SkTDArray<SkMultiPictureDraw_DrawData>) {
        SkMultiPictureDraw_DrawData_Reset(arg1)
    }
}
#[test]
fn bindgen_test_layout_SkMultiPictureDraw() {
    assert_eq!(
        ::core::mem::size_of::<SkMultiPictureDraw>(),
        32usize,
        concat!("Size of: ", stringify!(SkMultiPictureDraw))
    );
    assert_eq!(
        ::core::mem::align_of::<SkMultiPictureDraw>(),
        8usize,
        concat!("Alignment of ", stringify!(SkMultiPictureDraw))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkMultiPictureDraw>())).fThreadSafeDrawData as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkMultiPictureDraw),
            "::",
            stringify!(fThreadSafeDrawData)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkMultiPictureDraw>())).fGPUDrawData as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkMultiPictureDraw),
            "::",
            stringify!(fGPUDrawData)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN18SkMultiPictureDraw3addEP8SkCanvasPK9SkPicturePK8SkMatrixPK7SkPaint"]
    pub fn SkMultiPictureDraw_add(
        this: *mut SkMultiPictureDraw,
        canvas: *mut SkCanvas,
        picture: *const SkPicture,
        matrix: *const SkMatrix,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN18SkMultiPictureDraw4drawEb"]
    pub fn SkMultiPictureDraw_draw(this: *mut SkMultiPictureDraw, flush: bool);
}
extern "C" {
    #[link_name = "\u{1}_ZN18SkMultiPictureDraw5resetEv"]
    pub fn SkMultiPictureDraw_reset(this: *mut SkMultiPictureDraw);
}
extern "C" {
    #[link_name = "\u{1}_ZN18SkMultiPictureDrawC1Ei"]
    pub fn SkMultiPictureDraw_SkMultiPictureDraw(
        this: *mut SkMultiPictureDraw,
        reserve: ::std::os::raw::c_int,
    );
}
impl SkMultiPictureDraw {
    #[inline]
    pub unsafe fn add(
        &mut self,
        canvas: *mut SkCanvas,
        picture: *const SkPicture,
        matrix: *const SkMatrix,
        paint: *const SkPaint,
    ) {
        SkMultiPictureDraw_add(self, canvas, picture, matrix, paint)
    }
    #[inline]
    pub unsafe fn draw(&mut self, flush: bool) {
        SkMultiPictureDraw_draw(self, flush)
    }
    #[inline]
    pub unsafe fn reset(&mut self) {
        SkMultiPictureDraw_reset(self)
    }
    #[inline]
    pub unsafe fn new(reserve: ::std::os::raw::c_int) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkMultiPictureDraw_SkMultiPictureDraw(&mut __bindgen_tmp, reserve);
        __bindgen_tmp
    }
}
#[repr(C)]
pub struct SkPathMeasure {
    pub fIter: SkContourMeasureIter,
    pub fContour: sk_sp<SkContourMeasure>,
}
pub const SkPathMeasure_MatrixFlags_kGetPosition_MatrixFlag: SkPathMeasure_MatrixFlags = 1;
pub const SkPathMeasure_MatrixFlags_kGetTangent_MatrixFlag: SkPathMeasure_MatrixFlags = 2;
pub const SkPathMeasure_MatrixFlags_kGetPosAndTan_MatrixFlag: SkPathMeasure_MatrixFlags = 3;
pub type SkPathMeasure_MatrixFlags = u32;
#[test]
fn bindgen_test_layout_SkPathMeasure() {
    assert_eq!(
        ::core::mem::size_of::<SkPathMeasure>(),
        96usize,
        concat!("Size of: ", stringify!(SkPathMeasure))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPathMeasure>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPathMeasure))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathMeasure>())).fIter as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathMeasure),
            "::",
            stringify!(fIter)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPathMeasure>())).fContour as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPathMeasure),
            "::",
            stringify!(fContour)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkPathMeasure7setPathEPK6SkPathb"]
    pub fn SkPathMeasure_setPath(this: *mut SkPathMeasure, arg1: *const SkPath, forceClosed: bool);
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkPathMeasure9getLengthEv"]
    pub fn SkPathMeasure_getLength(this: *mut SkPathMeasure) -> SkScalar;
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkPathMeasure9getPosTanEfP7SkPointS1_"]
    pub fn SkPathMeasure_getPosTan(
        this: *mut SkPathMeasure,
        distance: SkScalar,
        position: *mut SkPoint,
        tangent: *mut SkVector,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkPathMeasure9getMatrixEfP8SkMatrixNS_11MatrixFlagsE"]
    pub fn SkPathMeasure_getMatrix(
        this: *mut SkPathMeasure,
        distance: SkScalar,
        matrix: *mut SkMatrix,
        flags: SkPathMeasure_MatrixFlags,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkPathMeasure10getSegmentEffP6SkPathb"]
    pub fn SkPathMeasure_getSegment(
        this: *mut SkPathMeasure,
        startD: SkScalar,
        stopD: SkScalar,
        dst: *mut SkPath,
        startWithMoveTo: bool,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkPathMeasure8isClosedEv"]
    pub fn SkPathMeasure_isClosed(this: *mut SkPathMeasure) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkPathMeasure11nextContourEv"]
    pub fn SkPathMeasure_nextContour(this: *mut SkPathMeasure) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkPathMeasureC1Ev"]
    pub fn SkPathMeasure_SkPathMeasure(this: *mut SkPathMeasure);
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkPathMeasureC1ERK6SkPathbf"]
    pub fn SkPathMeasure_SkPathMeasure1(
        this: *mut SkPathMeasure,
        path: *const SkPath,
        forceClosed: bool,
        resScale: SkScalar,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkPathMeasureD1Ev"]
    pub fn SkPathMeasure_SkPathMeasure_destructor(this: *mut SkPathMeasure);
}
impl SkPathMeasure {
    #[inline]
    pub unsafe fn setPath(&mut self, arg1: *const SkPath, forceClosed: bool) {
        SkPathMeasure_setPath(self, arg1, forceClosed)
    }
    #[inline]
    pub unsafe fn getLength(&mut self) -> SkScalar {
        SkPathMeasure_getLength(self)
    }
    #[inline]
    pub unsafe fn getPosTan(
        &mut self,
        distance: SkScalar,
        position: *mut SkPoint,
        tangent: *mut SkVector,
    ) -> bool {
        SkPathMeasure_getPosTan(self, distance, position, tangent)
    }
    #[inline]
    pub unsafe fn getMatrix(
        &mut self,
        distance: SkScalar,
        matrix: *mut SkMatrix,
        flags: SkPathMeasure_MatrixFlags,
    ) -> bool {
        SkPathMeasure_getMatrix(self, distance, matrix, flags)
    }
    #[inline]
    pub unsafe fn getSegment(
        &mut self,
        startD: SkScalar,
        stopD: SkScalar,
        dst: *mut SkPath,
        startWithMoveTo: bool,
    ) -> bool {
        SkPathMeasure_getSegment(self, startD, stopD, dst, startWithMoveTo)
    }
    #[inline]
    pub unsafe fn isClosed(&mut self) -> bool {
        SkPathMeasure_isClosed(self)
    }
    #[inline]
    pub unsafe fn nextContour(&mut self) -> bool {
        SkPathMeasure_nextContour(self)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkPathMeasure_SkPathMeasure(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(path: *const SkPath, forceClosed: bool, resScale: SkScalar) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkPathMeasure_SkPathMeasure1(&mut __bindgen_tmp, path, forceClosed, resScale);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        SkPathMeasure_SkPathMeasure_destructor(self)
    }
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub struct SkPicture {
    pub _bindgen_opaque_blob: [u64; 2usize],
}
#[repr(C)]
pub struct SkPicture_AbortCallback__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
pub struct SkPicture_AbortCallback {
    pub vtable_: *const SkPicture_AbortCallback__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_SkPicture_AbortCallback() {
    assert_eq!(
        ::core::mem::size_of::<SkPicture_AbortCallback>(),
        8usize,
        concat!("Size of: ", stringify!(SkPicture_AbortCallback))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPicture_AbortCallback>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPicture_AbortCallback))
    );
}
#[test]
fn bindgen_test_layout_SkPicture() {
    assert_eq!(
        ::core::mem::size_of::<SkPicture>(),
        16usize,
        concat!("Size of: ", stringify!(SkPicture))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPicture>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPicture))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkPicture14MakeFromStreamEP8SkStreamPK15SkDeserialProcs"]
    pub fn SkPicture_MakeFromStream(
        stream: *mut SkStream,
        procs: *const SkDeserialProcs,
    ) -> sk_sp<SkPicture>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkPicture12MakeFromDataEPK6SkDataPK15SkDeserialProcs"]
    pub fn SkPicture_MakeFromData(
        data: *const SkData,
        procs: *const SkDeserialProcs,
    ) -> sk_sp<SkPicture>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkPicture12MakeFromDataEPKvmPK15SkDeserialProcs"]
    pub fn SkPicture_MakeFromData1(
        data: *const ::std::os::raw::c_void,
        size: usize,
        procs: *const SkDeserialProcs,
    ) -> sk_sp<SkPicture>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkPicture9serializeEPK13SkSerialProcs"]
    pub fn SkPicture_serialize(
        this: *const SkPicture,
        procs: *const SkSerialProcs,
    ) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkPicture9serializeEP9SkWStreamPK13SkSerialProcs"]
    pub fn SkPicture_serialize1(
        this: *const SkPicture,
        stream: *mut SkWStream,
        procs: *const SkSerialProcs,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkPicture15MakePlaceholderE6SkRect"]
    pub fn SkPicture_MakePlaceholder(cull: SkRect) -> sk_sp<SkPicture>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkPicture10makeShaderE10SkTileModeS0_PK8SkMatrixPK6SkRect"]
    pub fn SkPicture_makeShader(
        this: *const SkPicture,
        tmx: SkTileMode,
        tmy: SkTileMode,
        localMatrix: *const SkMatrix,
        tileRect: *const SkRect,
    ) -> sk_sp<SkShader>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkPicture10makeShaderE10SkTileModeS0_PK8SkMatrix"]
    pub fn SkPicture_makeShader1(
        this: *const SkPicture,
        tmx: SkTileMode,
        tmy: SkTileMode,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader>;
}
impl SkPicture {
    #[inline]
    pub unsafe fn MakeFromStream(
        stream: *mut SkStream,
        procs: *const SkDeserialProcs,
    ) -> sk_sp<SkPicture> {
        SkPicture_MakeFromStream(stream, procs)
    }
    #[inline]
    pub unsafe fn MakeFromData(
        data: *const SkData,
        procs: *const SkDeserialProcs,
    ) -> sk_sp<SkPicture> {
        SkPicture_MakeFromData(data, procs)
    }
    #[inline]
    pub unsafe fn MakeFromData1(
        data: *const ::std::os::raw::c_void,
        size: usize,
        procs: *const SkDeserialProcs,
    ) -> sk_sp<SkPicture> {
        SkPicture_MakeFromData1(data, size, procs)
    }
    #[inline]
    pub unsafe fn serialize(&self, procs: *const SkSerialProcs) -> sk_sp<SkData> {
        SkPicture_serialize(self, procs)
    }
    #[inline]
    pub unsafe fn serialize1(&self, stream: *mut SkWStream, procs: *const SkSerialProcs) {
        SkPicture_serialize1(self, stream, procs)
    }
    #[inline]
    pub unsafe fn MakePlaceholder(cull: SkRect) -> sk_sp<SkPicture> {
        SkPicture_MakePlaceholder(cull)
    }
    #[inline]
    pub unsafe fn makeShader(
        &self,
        tmx: SkTileMode,
        tmy: SkTileMode,
        localMatrix: *const SkMatrix,
        tileRect: *const SkRect,
    ) -> sk_sp<SkShader> {
        SkPicture_makeShader(self, tmx, tmy, localMatrix, tileRect)
    }
    #[inline]
    pub unsafe fn makeShader1(
        &self,
        tmx: SkTileMode,
        tmy: SkTileMode,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader> {
        SkPicture_makeShader1(self, tmx, tmy, localMatrix)
    }
}
pub const SkPicture_MIN_PICTURE_VERSION: u32 = 56;
pub const SkPicture_CURRENT_PICTURE_VERSION: u32 = 68;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkBBoxHierarchy {
    _unused: [u8; 0],
}
#[repr(C)]
pub struct SkBBHFactory__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
pub struct SkBBHFactory {
    pub vtable_: *const SkBBHFactory__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_SkBBHFactory() {
    assert_eq!(
        ::core::mem::size_of::<SkBBHFactory>(),
        8usize,
        concat!("Size of: ", stringify!(SkBBHFactory))
    );
    assert_eq!(
        ::core::mem::align_of::<SkBBHFactory>(),
        8usize,
        concat!("Alignment of ", stringify!(SkBBHFactory))
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkMiniRecorder {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkRecord {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkRecorder {
    _unused: [u8; 0],
}
#[repr(C)]
pub struct SkPictureRecorder {
    pub fActivelyRecording: bool,
    pub fFlags: u32,
    pub fCullRect: SkRect,
    pub fBBH: sk_sp<SkBBoxHierarchy>,
    pub fRecorder: u64,
    pub fRecord: sk_sp<SkRecord>,
    pub fMiniRecorder: u64,
}
pub const SkPictureRecorder_RecordFlags_kPlaybackDrawPicture_RecordFlag:
    SkPictureRecorder_RecordFlags = 1;
pub type SkPictureRecorder_RecordFlags = u32;
pub type SkPictureRecorder_FinishFlags = u32;
#[test]
fn bindgen_test_layout_SkPictureRecorder() {
    assert_eq!(
        ::core::mem::size_of::<SkPictureRecorder>(),
        56usize,
        concat!("Size of: ", stringify!(SkPictureRecorder))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPictureRecorder>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPictureRecorder))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkPictureRecorder>())).fActivelyRecording as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPictureRecorder),
            "::",
            stringify!(fActivelyRecording)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPictureRecorder>())).fFlags as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPictureRecorder),
            "::",
            stringify!(fFlags)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPictureRecorder>())).fCullRect as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPictureRecorder),
            "::",
            stringify!(fCullRect)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPictureRecorder>())).fBBH as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPictureRecorder),
            "::",
            stringify!(fBBH)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPictureRecorder>())).fRecorder as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPictureRecorder),
            "::",
            stringify!(fRecorder)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPictureRecorder>())).fRecord as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPictureRecorder),
            "::",
            stringify!(fRecord)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkPictureRecorder>())).fMiniRecorder as *const _ as usize
        },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPictureRecorder),
            "::",
            stringify!(fMiniRecorder)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkPictureRecorder14beginRecordingERK6SkRectP12SkBBHFactoryj"]
    pub fn SkPictureRecorder_beginRecording(
        this: *mut SkPictureRecorder,
        bounds: *const SkRect,
        bbhFactory: *mut SkBBHFactory,
        recordFlags: u32,
    ) -> *mut SkCanvas;
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkPictureRecorder18getRecordingCanvasEv"]
    pub fn SkPictureRecorder_getRecordingCanvas(this: *mut SkPictureRecorder) -> *mut SkCanvas;
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkPictureRecorder24finishRecordingAsPictureEj"]
    pub fn SkPictureRecorder_finishRecordingAsPicture(
        this: *mut SkPictureRecorder,
        endFlags: u32,
    ) -> sk_sp<SkPicture>;
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkPictureRecorder32finishRecordingAsPictureWithCullERK6SkRectj"]
    pub fn SkPictureRecorder_finishRecordingAsPictureWithCull(
        this: *mut SkPictureRecorder,
        cullRect: *const SkRect,
        endFlags: u32,
    ) -> sk_sp<SkPicture>;
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkPictureRecorder25finishRecordingAsDrawableEj"]
    pub fn SkPictureRecorder_finishRecordingAsDrawable(
        this: *mut SkPictureRecorder,
        endFlags: u32,
    ) -> sk_sp<SkDrawable>;
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkPictureRecorderC1Ev"]
    pub fn SkPictureRecorder_SkPictureRecorder(this: *mut SkPictureRecorder);
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkPictureRecorderD1Ev"]
    pub fn SkPictureRecorder_SkPictureRecorder_destructor(this: *mut SkPictureRecorder);
}
impl SkPictureRecorder {
    #[inline]
    pub unsafe fn beginRecording(
        &mut self,
        bounds: *const SkRect,
        bbhFactory: *mut SkBBHFactory,
        recordFlags: u32,
    ) -> *mut SkCanvas {
        SkPictureRecorder_beginRecording(self, bounds, bbhFactory, recordFlags)
    }
    #[inline]
    pub unsafe fn getRecordingCanvas(&mut self) -> *mut SkCanvas {
        SkPictureRecorder_getRecordingCanvas(self)
    }
    #[inline]
    pub unsafe fn finishRecordingAsPicture(&mut self, endFlags: u32) -> sk_sp<SkPicture> {
        SkPictureRecorder_finishRecordingAsPicture(self, endFlags)
    }
    #[inline]
    pub unsafe fn finishRecordingAsPictureWithCull(
        &mut self,
        cullRect: *const SkRect,
        endFlags: u32,
    ) -> sk_sp<SkPicture> {
        SkPictureRecorder_finishRecordingAsPictureWithCull(self, cullRect, endFlags)
    }
    #[inline]
    pub unsafe fn finishRecordingAsDrawable(&mut self, endFlags: u32) -> sk_sp<SkDrawable> {
        SkPictureRecorder_finishRecordingAsDrawable(self, endFlags)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkPictureRecorder_SkPictureRecorder(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        SkPictureRecorder_SkPictureRecorder_destructor(self)
    }
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub struct SkPixelRef {
    pub _bindgen_opaque_blob: [u64; 11usize],
}
#[repr(C)]
pub struct SkPixelRef_GenIDChangeListener__bindgen_vtable(::std::os::raw::c_void);
#[repr(C)]
pub struct SkPixelRef_GenIDChangeListener {
    pub vtable_: *const SkPixelRef_GenIDChangeListener__bindgen_vtable,
}
#[test]
fn bindgen_test_layout_SkPixelRef_GenIDChangeListener() {
    assert_eq!(
        ::core::mem::size_of::<SkPixelRef_GenIDChangeListener>(),
        8usize,
        concat!("Size of: ", stringify!(SkPixelRef_GenIDChangeListener))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPixelRef_GenIDChangeListener>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPixelRef_GenIDChangeListener))
    );
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkPixelRef_Mutability {
    kMutable = 0,
    kTemporarilyImmutable = 1,
    kImmutable = 2,
}
pub type SkPixelRef_INHERITED = SkRefCnt;
#[test]
fn bindgen_test_layout_SkPixelRef() {
    assert_eq!(
        ::core::mem::size_of::<SkPixelRef>(),
        88usize,
        concat!("Size of: ", stringify!(SkPixelRef))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPixelRef>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPixelRef))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkPixelRef15getGenerationIDEv"]
    pub fn SkPixelRef_getGenerationID(this: *const SkPixelRef) -> u32;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkPixelRef19notifyPixelsChangedEv"]
    pub fn SkPixelRef_notifyPixelsChanged(this: *mut SkPixelRef);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkPixelRef12setImmutableEv"]
    pub fn SkPixelRef_setImmutable(this: *mut SkPixelRef);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkPixelRef22addGenIDChangeListenerEPNS_19GenIDChangeListenerE"]
    pub fn SkPixelRef_addGenIDChangeListener(
        this: *mut SkPixelRef,
        listener: *mut SkPixelRef_GenIDChangeListener,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkPixelRef18android_only_resetEiim"]
    pub fn SkPixelRef_android_only_reset(
        this: *mut SkPixelRef,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        rowBytes: usize,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkPixelRefC1EiiPvm"]
    pub fn SkPixelRef_SkPixelRef(
        this: *mut SkPixelRef,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        addr: *mut ::std::os::raw::c_void,
        rowBytes: usize,
    );
}
impl SkPixelRef {
    #[inline]
    pub unsafe fn getGenerationID(&self) -> u32 {
        SkPixelRef_getGenerationID(self)
    }
    #[inline]
    pub unsafe fn notifyPixelsChanged(&mut self) {
        SkPixelRef_notifyPixelsChanged(self)
    }
    #[inline]
    pub unsafe fn setImmutable(&mut self) {
        SkPixelRef_setImmutable(self)
    }
    #[inline]
    pub unsafe fn addGenIDChangeListener(&mut self, listener: *mut SkPixelRef_GenIDChangeListener) {
        SkPixelRef_addGenIDChangeListener(self, listener)
    }
    #[inline]
    pub unsafe fn android_only_reset(
        &mut self,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        rowBytes: usize,
    ) {
        SkPixelRef_android_only_reset(self, width, height, rowBytes)
    }
    #[inline]
    pub unsafe fn new(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        addr: *mut ::std::os::raw::c_void,
        rowBytes: usize,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkPixelRef_SkPixelRef(&mut __bindgen_tmp, width, height, addr, rowBytes);
        __bindgen_tmp
    }
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkPixelRefD1Ev"]
    pub fn SkPixelRef_SkPixelRef_destructor(this: *mut SkPixelRef);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkPoint3 {
    pub fX: SkScalar,
    pub fY: SkScalar,
    pub fZ: SkScalar,
}
#[test]
fn bindgen_test_layout_SkPoint3() {
    assert_eq!(
        ::core::mem::size_of::<SkPoint3>(),
        12usize,
        concat!("Size of: ", stringify!(SkPoint3))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPoint3>(),
        4usize,
        concat!("Alignment of ", stringify!(SkPoint3))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPoint3>())).fX as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPoint3),
            "::",
            stringify!(fX)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPoint3>())).fY as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPoint3),
            "::",
            stringify!(fY)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPoint3>())).fZ as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPoint3),
            "::",
            stringify!(fZ)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkPoint36LengthEfff"]
    pub fn SkPoint3_Length(x: SkScalar, y: SkScalar, z: SkScalar) -> SkScalar;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkPoint39normalizeEv"]
    pub fn SkPoint3_normalize(this: *mut SkPoint3) -> bool;
}
impl SkPoint3 {
    #[inline]
    pub unsafe fn Length(x: SkScalar, y: SkScalar, z: SkScalar) -> SkScalar {
        SkPoint3_Length(x, y, z)
    }
    #[inline]
    pub unsafe fn normalize(&mut self) -> bool {
        SkPoint3_normalize(self)
    }
}
#[repr(C)]
pub struct SkRegion {
    pub fBounds: SkIRect,
    pub fRunHead: *mut SkRegion_RunHead,
}
pub type SkRegion_RunType = i32;
impl SkRegion_Op {
    pub const kLastOp: SkRegion_Op = SkRegion_Op::kReplace_Op;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkRegion_Op {
    kDifference_Op = 0,
    kIntersect_Op = 1,
    kUnion_Op = 2,
    kXOR_Op = 3,
    kReverseDifference_Op = 4,
    kReplace_Op = 5,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkRegion_Iterator {
    pub fRgn: *const SkRegion,
    pub fRuns: *const SkRegion_RunType,
    pub fRect: SkIRect,
    pub fDone: bool,
}
#[test]
fn bindgen_test_layout_SkRegion_Iterator() {
    assert_eq!(
        ::core::mem::size_of::<SkRegion_Iterator>(),
        40usize,
        concat!("Size of: ", stringify!(SkRegion_Iterator))
    );
    assert_eq!(
        ::core::mem::align_of::<SkRegion_Iterator>(),
        8usize,
        concat!("Alignment of ", stringify!(SkRegion_Iterator))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRegion_Iterator>())).fRgn as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRegion_Iterator),
            "::",
            stringify!(fRgn)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRegion_Iterator>())).fRuns as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRegion_Iterator),
            "::",
            stringify!(fRuns)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRegion_Iterator>())).fRect as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRegion_Iterator),
            "::",
            stringify!(fRect)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRegion_Iterator>())).fDone as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRegion_Iterator),
            "::",
            stringify!(fDone)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegion8Iterator6rewindEv"]
    pub fn SkRegion_Iterator_rewind(this: *mut SkRegion_Iterator) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegion8Iterator5resetERKS_"]
    pub fn SkRegion_Iterator_reset(this: *mut SkRegion_Iterator, region: *const SkRegion);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegion8Iterator4nextEv"]
    pub fn SkRegion_Iterator_next(this: *mut SkRegion_Iterator);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegion8IteratorC1ERKS_"]
    pub fn SkRegion_Iterator_Iterator(this: *mut SkRegion_Iterator, region: *const SkRegion);
}
impl SkRegion_Iterator {
    #[inline]
    pub unsafe fn rewind(&mut self) -> bool {
        SkRegion_Iterator_rewind(self)
    }
    #[inline]
    pub unsafe fn reset(&mut self, region: *const SkRegion) {
        SkRegion_Iterator_reset(self, region)
    }
    #[inline]
    pub unsafe fn next(&mut self) {
        SkRegion_Iterator_next(self)
    }
    #[inline]
    pub unsafe fn new(region: *const SkRegion) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkRegion_Iterator_Iterator(&mut __bindgen_tmp, region);
        __bindgen_tmp
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkRegion_Cliperator {
    pub fIter: SkRegion_Iterator,
    pub fClip: SkIRect,
    pub fRect: SkIRect,
    pub fDone: bool,
}
#[test]
fn bindgen_test_layout_SkRegion_Cliperator() {
    assert_eq!(
        ::core::mem::size_of::<SkRegion_Cliperator>(),
        80usize,
        concat!("Size of: ", stringify!(SkRegion_Cliperator))
    );
    assert_eq!(
        ::core::mem::align_of::<SkRegion_Cliperator>(),
        8usize,
        concat!("Alignment of ", stringify!(SkRegion_Cliperator))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRegion_Cliperator>())).fIter as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRegion_Cliperator),
            "::",
            stringify!(fIter)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRegion_Cliperator>())).fClip as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRegion_Cliperator),
            "::",
            stringify!(fClip)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRegion_Cliperator>())).fRect as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRegion_Cliperator),
            "::",
            stringify!(fRect)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRegion_Cliperator>())).fDone as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRegion_Cliperator),
            "::",
            stringify!(fDone)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegion10Cliperator4nextEv"]
    pub fn SkRegion_Cliperator_next(this: *mut SkRegion_Cliperator);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegion10CliperatorC1ERKS_RK7SkIRect"]
    pub fn SkRegion_Cliperator_Cliperator(
        this: *mut SkRegion_Cliperator,
        region: *const SkRegion,
        clip: *const SkIRect,
    );
}
impl SkRegion_Cliperator {
    #[inline]
    pub unsafe fn next(&mut self) {
        SkRegion_Cliperator_next(self)
    }
    #[inline]
    pub unsafe fn new(region: *const SkRegion, clip: *const SkIRect) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkRegion_Cliperator_Cliperator(&mut __bindgen_tmp, region, clip);
        __bindgen_tmp
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkRegion_Spanerator {
    pub fRuns: *const SkRegion_RunType,
    pub fLeft: ::std::os::raw::c_int,
    pub fRight: ::std::os::raw::c_int,
    pub fDone: bool,
}
#[test]
fn bindgen_test_layout_SkRegion_Spanerator() {
    assert_eq!(
        ::core::mem::size_of::<SkRegion_Spanerator>(),
        24usize,
        concat!("Size of: ", stringify!(SkRegion_Spanerator))
    );
    assert_eq!(
        ::core::mem::align_of::<SkRegion_Spanerator>(),
        8usize,
        concat!("Alignment of ", stringify!(SkRegion_Spanerator))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRegion_Spanerator>())).fRuns as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRegion_Spanerator),
            "::",
            stringify!(fRuns)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRegion_Spanerator>())).fLeft as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRegion_Spanerator),
            "::",
            stringify!(fLeft)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRegion_Spanerator>())).fRight as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRegion_Spanerator),
            "::",
            stringify!(fRight)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRegion_Spanerator>())).fDone as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRegion_Spanerator),
            "::",
            stringify!(fDone)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegion10Spanerator4nextEPiS1_"]
    pub fn SkRegion_Spanerator_next(
        this: *mut SkRegion_Spanerator,
        left: *mut ::std::os::raw::c_int,
        right: *mut ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegion10SpaneratorC1ERKS_iii"]
    pub fn SkRegion_Spanerator_Spanerator(
        this: *mut SkRegion_Spanerator,
        region: *const SkRegion,
        y: ::std::os::raw::c_int,
        left: ::std::os::raw::c_int,
        right: ::std::os::raw::c_int,
    );
}
impl SkRegion_Spanerator {
    #[inline]
    pub unsafe fn next(
        &mut self,
        left: *mut ::std::os::raw::c_int,
        right: *mut ::std::os::raw::c_int,
    ) -> bool {
        SkRegion_Spanerator_next(self, left, right)
    }
    #[inline]
    pub unsafe fn new(
        region: *const SkRegion,
        y: ::std::os::raw::c_int,
        left: ::std::os::raw::c_int,
        right: ::std::os::raw::c_int,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkRegion_Spanerator_Spanerator(&mut __bindgen_tmp, region, y, left, right);
        __bindgen_tmp
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkRegion_RunHead {
    _unused: [u8; 0],
}
pub const SkRegion_kOpCnt: ::std::os::raw::c_int = 6;
pub const SkRegion_kOpCount: ::std::os::raw::c_int = 6;
pub const SkRegion_kRectRegionRuns: ::std::os::raw::c_int = 7;
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegion15kRectRunHeadPtrE"]
    pub static SkRegion_kRectRunHeadPtr: *mut SkRegion_RunHead;
}
#[test]
fn bindgen_test_layout_SkRegion() {
    assert_eq!(
        ::core::mem::size_of::<SkRegion>(),
        24usize,
        concat!("Size of: ", stringify!(SkRegion))
    );
    assert_eq!(
        ::core::mem::align_of::<SkRegion>(),
        8usize,
        concat!("Alignment of ", stringify!(SkRegion))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRegion>())).fBounds as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRegion),
            "::",
            stringify!(fBounds)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRegion>())).fRunHead as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRegion),
            "::",
            stringify!(fRunHead)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegion4swapERS_"]
    pub fn SkRegion_swap(this: *mut SkRegion, other: *mut SkRegion);
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkRegion23computeRegionComplexityEv"]
    pub fn SkRegion_computeRegionComplexity(this: *const SkRegion) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkRegion15getBoundaryPathEP6SkPath"]
    pub fn SkRegion_getBoundaryPath(this: *const SkRegion, path: *mut SkPath) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegion8setEmptyEv"]
    pub fn SkRegion_setEmpty(this: *mut SkRegion) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegion7setRectERK7SkIRect"]
    pub fn SkRegion_setRect(this: *mut SkRegion, rect: *const SkIRect) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegion8setRectsEPK7SkIRecti"]
    pub fn SkRegion_setRects(
        this: *mut SkRegion,
        rects: *const SkIRect,
        count: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegion9setRegionERKS_"]
    pub fn SkRegion_setRegion(this: *mut SkRegion, region: *const SkRegion) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegion7setPathERK6SkPathRKS_"]
    pub fn SkRegion_setPath(
        this: *mut SkRegion,
        path: *const SkPath,
        clip: *const SkRegion,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkRegion10intersectsERK7SkIRect"]
    pub fn SkRegion_intersects(this: *const SkRegion, rect: *const SkIRect) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkRegion10intersectsERKS_"]
    pub fn SkRegion_intersects1(this: *const SkRegion, other: *const SkRegion) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkRegion8containsEii"]
    pub fn SkRegion_contains(this: *const SkRegion, x: i32, y: i32) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkRegion8containsERK7SkIRect"]
    pub fn SkRegion_contains1(this: *const SkRegion, other: *const SkIRect) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkRegion8containsERKS_"]
    pub fn SkRegion_contains2(this: *const SkRegion, other: *const SkRegion) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkRegion9translateEiiPS_"]
    pub fn SkRegion_translate(
        this: *const SkRegion,
        dx: ::std::os::raw::c_int,
        dy: ::std::os::raw::c_int,
        dst: *mut SkRegion,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegion2opERK7SkIRectRKS_NS_2OpE"]
    pub fn SkRegion_op(
        this: *mut SkRegion,
        rect: *const SkIRect,
        rgn: *const SkRegion,
        op: SkRegion_Op,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegion2opERKS_RK7SkIRectNS_2OpE"]
    pub fn SkRegion_op1(
        this: *mut SkRegion,
        rgn: *const SkRegion,
        rect: *const SkIRect,
        op: SkRegion_Op,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegion2opERKS_S1_NS_2OpE"]
    pub fn SkRegion_op2(
        this: *mut SkRegion,
        rgna: *const SkRegion,
        rgnb: *const SkRegion,
        op: SkRegion_Op,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK8SkRegion13writeToMemoryEPv"]
    pub fn SkRegion_writeToMemory(
        this: *const SkRegion,
        buffer: *mut ::std::os::raw::c_void,
    ) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegion14readFromMemoryEPKvm"]
    pub fn SkRegion_readFromMemory(
        this: *mut SkRegion,
        buffer: *const ::std::os::raw::c_void,
        length: usize,
    ) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegionC1Ev"]
    pub fn SkRegion_SkRegion(this: *mut SkRegion);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegionC1ERKS_"]
    pub fn SkRegion_SkRegion1(this: *mut SkRegion, region: *const SkRegion);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegionC1ERK7SkIRect"]
    pub fn SkRegion_SkRegion2(this: *mut SkRegion, rect: *const SkIRect);
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkRegionD1Ev"]
    pub fn SkRegion_SkRegion_destructor(this: *mut SkRegion);
}
impl SkRegion {
    #[inline]
    pub unsafe fn swap(&mut self, other: *mut SkRegion) {
        SkRegion_swap(self, other)
    }
    #[inline]
    pub unsafe fn computeRegionComplexity(&self) -> ::std::os::raw::c_int {
        SkRegion_computeRegionComplexity(self)
    }
    #[inline]
    pub unsafe fn getBoundaryPath(&self, path: *mut SkPath) -> bool {
        SkRegion_getBoundaryPath(self, path)
    }
    #[inline]
    pub unsafe fn setEmpty(&mut self) -> bool {
        SkRegion_setEmpty(self)
    }
    #[inline]
    pub unsafe fn setRect(&mut self, rect: *const SkIRect) -> bool {
        SkRegion_setRect(self, rect)
    }
    #[inline]
    pub unsafe fn setRects(&mut self, rects: *const SkIRect, count: ::std::os::raw::c_int) -> bool {
        SkRegion_setRects(self, rects, count)
    }
    #[inline]
    pub unsafe fn setRegion(&mut self, region: *const SkRegion) -> bool {
        SkRegion_setRegion(self, region)
    }
    #[inline]
    pub unsafe fn setPath(&mut self, path: *const SkPath, clip: *const SkRegion) -> bool {
        SkRegion_setPath(self, path, clip)
    }
    #[inline]
    pub unsafe fn intersects(&self, rect: *const SkIRect) -> bool {
        SkRegion_intersects(self, rect)
    }
    #[inline]
    pub unsafe fn intersects1(&self, other: *const SkRegion) -> bool {
        SkRegion_intersects1(self, other)
    }
    #[inline]
    pub unsafe fn contains(&self, x: i32, y: i32) -> bool {
        SkRegion_contains(self, x, y)
    }
    #[inline]
    pub unsafe fn contains1(&self, other: *const SkIRect) -> bool {
        SkRegion_contains1(self, other)
    }
    #[inline]
    pub unsafe fn contains2(&self, other: *const SkRegion) -> bool {
        SkRegion_contains2(self, other)
    }
    #[inline]
    pub unsafe fn translate(
        &self,
        dx: ::std::os::raw::c_int,
        dy: ::std::os::raw::c_int,
        dst: *mut SkRegion,
    ) {
        SkRegion_translate(self, dx, dy, dst)
    }
    #[inline]
    pub unsafe fn op(
        &mut self,
        rect: *const SkIRect,
        rgn: *const SkRegion,
        op: SkRegion_Op,
    ) -> bool {
        SkRegion_op(self, rect, rgn, op)
    }
    #[inline]
    pub unsafe fn op1(
        &mut self,
        rgn: *const SkRegion,
        rect: *const SkIRect,
        op: SkRegion_Op,
    ) -> bool {
        SkRegion_op1(self, rgn, rect, op)
    }
    #[inline]
    pub unsafe fn op2(
        &mut self,
        rgna: *const SkRegion,
        rgnb: *const SkRegion,
        op: SkRegion_Op,
    ) -> bool {
        SkRegion_op2(self, rgna, rgnb, op)
    }
    #[inline]
    pub unsafe fn writeToMemory(&self, buffer: *mut ::std::os::raw::c_void) -> usize {
        SkRegion_writeToMemory(self, buffer)
    }
    #[inline]
    pub unsafe fn readFromMemory(
        &mut self,
        buffer: *const ::std::os::raw::c_void,
        length: usize,
    ) -> usize {
        SkRegion_readFromMemory(self, buffer, length)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkRegion_SkRegion(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(region: *const SkRegion) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkRegion_SkRegion1(&mut __bindgen_tmp, region);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new2(rect: *const SkIRect) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkRegion_SkRegion2(&mut __bindgen_tmp, rect);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        SkRegion_SkRegion_destructor(self)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkRSXform {
    pub fSCos: SkScalar,
    pub fSSin: SkScalar,
    pub fTx: SkScalar,
    pub fTy: SkScalar,
}
#[test]
fn bindgen_test_layout_SkRSXform() {
    assert_eq!(
        ::core::mem::size_of::<SkRSXform>(),
        16usize,
        concat!("Size of: ", stringify!(SkRSXform))
    );
    assert_eq!(
        ::core::mem::align_of::<SkRSXform>(),
        4usize,
        concat!("Alignment of ", stringify!(SkRSXform))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRSXform>())).fSCos as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRSXform),
            "::",
            stringify!(fSCos)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRSXform>())).fSSin as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRSXform),
            "::",
            stringify!(fSSin)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRSXform>())).fTx as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRSXform),
            "::",
            stringify!(fTx)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkRSXform>())).fTy as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(SkRSXform),
            "::",
            stringify!(fTy)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkRSXform6toQuadEffP7SkPoint"]
    pub fn SkRSXform_toQuad(
        this: *const SkRSXform,
        width: SkScalar,
        height: SkScalar,
        quad: *mut SkPoint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkRSXform10toTriStripEffP7SkPoint"]
    pub fn SkRSXform_toTriStrip(
        this: *const SkRSXform,
        width: SkScalar,
        height: SkScalar,
        strip: *mut SkPoint,
    );
}
impl SkRSXform {
    #[inline]
    pub unsafe fn toQuad(&self, width: SkScalar, height: SkScalar, quad: *mut SkPoint) {
        SkRSXform_toQuad(self, width, height, quad)
    }
    #[inline]
    pub unsafe fn toTriStrip(&self, width: SkScalar, height: SkScalar, strip: *mut SkPoint) {
        SkRSXform_toTriStrip(self, width, height, strip)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkStrokeRec {
    pub fResScale: SkScalar,
    pub fWidth: SkScalar,
    pub fMiterLimit: SkScalar,
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u16>,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkStrokeRec_InitStyle {
    kHairline_InitStyle = 0,
    kFill_InitStyle = 1,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkStrokeRec_Style {
    kHairline_Style = 0,
    kFill_Style = 1,
    kStroke_Style = 2,
    kStrokeAndFill_Style = 3,
}
pub const SkStrokeRec_kStyleCount: ::std::os::raw::c_int = 4;
#[test]
fn bindgen_test_layout_SkStrokeRec() {
    assert_eq!(
        ::core::mem::size_of::<SkStrokeRec>(),
        16usize,
        concat!("Size of: ", stringify!(SkStrokeRec))
    );
    assert_eq!(
        ::core::mem::align_of::<SkStrokeRec>(),
        4usize,
        concat!("Alignment of ", stringify!(SkStrokeRec))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkStrokeRec>())).fResScale as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkStrokeRec),
            "::",
            stringify!(fResScale)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkStrokeRec>())).fWidth as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkStrokeRec),
            "::",
            stringify!(fWidth)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkStrokeRec>())).fMiterLimit as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkStrokeRec),
            "::",
            stringify!(fMiterLimit)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK11SkStrokeRec8getStyleEv"]
    pub fn SkStrokeRec_getStyle(this: *const SkStrokeRec) -> SkStrokeRec_Style;
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkStrokeRec12setFillStyleEv"]
    pub fn SkStrokeRec_setFillStyle(this: *mut SkStrokeRec);
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkStrokeRec16setHairlineStyleEv"]
    pub fn SkStrokeRec_setHairlineStyle(this: *mut SkStrokeRec);
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkStrokeRec14setStrokeStyleEfb"]
    pub fn SkStrokeRec_setStrokeStyle(this: *mut SkStrokeRec, width: SkScalar, strokeAndFill: bool);
}
extern "C" {
    #[link_name = "\u{1}_ZNK11SkStrokeRec11applyToPathEP6SkPathRKS0_"]
    pub fn SkStrokeRec_applyToPath(
        this: *const SkStrokeRec,
        dst: *mut SkPath,
        src: *const SkPath,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK11SkStrokeRec12applyToPaintEP7SkPaint"]
    pub fn SkStrokeRec_applyToPaint(this: *const SkStrokeRec, paint: *mut SkPaint);
}
extern "C" {
    #[link_name = "\u{1}_ZNK11SkStrokeRec18getInflationRadiusEv"]
    pub fn SkStrokeRec_getInflationRadius(this: *const SkStrokeRec) -> SkScalar;
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkStrokeRec18GetInflationRadiusERK7SkPaintNS0_5StyleE"]
    pub fn SkStrokeRec_GetInflationRadius(arg1: *const SkPaint, arg2: SkPaint_Style) -> SkScalar;
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkStrokeRec18GetInflationRadiusEN7SkPaint4JoinEfNS0_3CapEf"]
    pub fn SkStrokeRec_GetInflationRadius1(
        arg1: SkPaint_Join,
        miterLimit: SkScalar,
        arg2: SkPaint_Cap,
        strokeWidth: SkScalar,
    ) -> SkScalar;
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkStrokeRecC1ENS_9InitStyleE"]
    pub fn SkStrokeRec_SkStrokeRec(this: *mut SkStrokeRec, style: SkStrokeRec_InitStyle);
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkStrokeRecC1ERK7SkPaintNS0_5StyleEf"]
    pub fn SkStrokeRec_SkStrokeRec1(
        this: *mut SkStrokeRec,
        arg1: *const SkPaint,
        arg2: SkPaint_Style,
        resScale: SkScalar,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkStrokeRecC1ERK7SkPaintf"]
    pub fn SkStrokeRec_SkStrokeRec2(
        this: *mut SkStrokeRec,
        arg1: *const SkPaint,
        resScale: SkScalar,
    );
}
impl SkStrokeRec {
    #[inline]
    pub fn fCap(&self) -> u32 {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
    }
    #[inline]
    pub fn set_fCap(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(0usize, 16u8, val as u64)
        }
    }
    #[inline]
    pub fn fJoin(&self) -> u32 {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(16usize, 15u8) as u32) }
    }
    #[inline]
    pub fn set_fJoin(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(16usize, 15u8, val as u64)
        }
    }
    #[inline]
    pub fn fStrokeAndFill(&self) -> u32 {
        unsafe { ::core::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_fStrokeAndFill(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::core::mem::transmute(val);
            self._bitfield_1.set(31usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        fCap: u32,
        fJoin: u32,
        fStrokeAndFill: u32,
    ) -> __BindgenBitfieldUnit<[u8; 4usize], u16> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u16> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 16u8, {
            let fCap: u32 = unsafe { ::core::mem::transmute(fCap) };
            fCap as u64
        });
        __bindgen_bitfield_unit.set(16usize, 15u8, {
            let fJoin: u32 = unsafe { ::core::mem::transmute(fJoin) };
            fJoin as u64
        });
        __bindgen_bitfield_unit.set(31usize, 1u8, {
            let fStrokeAndFill: u32 = unsafe { ::core::mem::transmute(fStrokeAndFill) };
            fStrokeAndFill as u64
        });
        __bindgen_bitfield_unit
    }
    #[inline]
    pub unsafe fn getStyle(&self) -> SkStrokeRec_Style {
        SkStrokeRec_getStyle(self)
    }
    #[inline]
    pub unsafe fn setFillStyle(&mut self) {
        SkStrokeRec_setFillStyle(self)
    }
    #[inline]
    pub unsafe fn setHairlineStyle(&mut self) {
        SkStrokeRec_setHairlineStyle(self)
    }
    #[inline]
    pub unsafe fn setStrokeStyle(&mut self, width: SkScalar, strokeAndFill: bool) {
        SkStrokeRec_setStrokeStyle(self, width, strokeAndFill)
    }
    #[inline]
    pub unsafe fn applyToPath(&self, dst: *mut SkPath, src: *const SkPath) -> bool {
        SkStrokeRec_applyToPath(self, dst, src)
    }
    #[inline]
    pub unsafe fn applyToPaint(&self, paint: *mut SkPaint) {
        SkStrokeRec_applyToPaint(self, paint)
    }
    #[inline]
    pub unsafe fn getInflationRadius(&self) -> SkScalar {
        SkStrokeRec_getInflationRadius(self)
    }
    #[inline]
    pub unsafe fn GetInflationRadius(arg1: *const SkPaint, arg2: SkPaint_Style) -> SkScalar {
        SkStrokeRec_GetInflationRadius(arg1, arg2)
    }
    #[inline]
    pub unsafe fn GetInflationRadius1(
        arg1: SkPaint_Join,
        miterLimit: SkScalar,
        arg2: SkPaint_Cap,
        strokeWidth: SkScalar,
    ) -> SkScalar {
        SkStrokeRec_GetInflationRadius1(arg1, miterLimit, arg2, strokeWidth)
    }
    #[inline]
    pub unsafe fn new(style: SkStrokeRec_InitStyle) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkStrokeRec_SkStrokeRec(&mut __bindgen_tmp, style);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(arg1: *const SkPaint, arg2: SkPaint_Style, resScale: SkScalar) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkStrokeRec_SkStrokeRec1(&mut __bindgen_tmp, arg1, arg2, resScale);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new2(arg1: *const SkPaint, resScale: SkScalar) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkStrokeRec_SkStrokeRec2(&mut __bindgen_tmp, arg1, resScale);
        __bindgen_tmp
    }
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub struct SkSurface {
    pub _bindgen_opaque_blob: [u64; 4usize],
}
pub type SkSurface_ReleaseContext = *mut ::std::os::raw::c_void;
pub type SkSurface_RenderTargetReleaseProc =
    ::core::option::Option<unsafe extern "C" fn(releaseContext: SkSurface_ReleaseContext)>;
pub type SkSurface_TextureReleaseProc =
    ::core::option::Option<unsafe extern "C" fn(releaseContext: SkSurface_ReleaseContext)>;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkSurface_ContentChangeMode {
    kDiscard_ContentChangeMode = 0,
    kRetain_ContentChangeMode = 1,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkSurface_BackendHandleAccess {
    kFlushRead_BackendHandleAccess = 0,
    kFlushWrite_BackendHandleAccess = 1,
    kDiscardWrite_BackendHandleAccess = 2,
}
pub type SkSurface_ReadPixelsContext = *mut ::std::os::raw::c_void;
pub type SkSurface_ReadPixelsCallback = ::core::option::Option<
    unsafe extern "C" fn(
        arg1: SkSurface_ReadPixelsContext,
        data: *const ::std::os::raw::c_void,
        rowBytes: usize,
    ),
>;
#[repr(u8)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkSurface_RescaleGamma {
    kSrc = 0,
    kLinear = 1,
}
pub type SkSurface_ReadPixelsCallbackYUV420 = ::core::option::Option<
    unsafe extern "C" fn(
        arg1: SkSurface_ReadPixelsContext,
        data: *mut *const ::std::os::raw::c_void,
        rowBytes: *mut usize,
    ),
>;
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkSurface_BackendSurfaceAccess {
    kNoAccess = 0,
    kPresent = 1,
}
pub const SkSurface_FlushFlags_kNone_FlushFlags: SkSurface_FlushFlags = 0;
pub const SkSurface_FlushFlags_kSyncCpu_FlushFlag: SkSurface_FlushFlags = 1;
pub type SkSurface_FlushFlags = u32;
pub type SkSurface_INHERITED = SkRefCnt;
#[test]
fn bindgen_test_layout_SkSurface() {
    assert_eq!(
        ::core::mem::size_of::<SkSurface>(),
        32usize,
        concat!("Size of: ", stringify!(SkSurface))
    );
    assert_eq!(
        ::core::mem::align_of::<SkSurface>(),
        8usize,
        concat!("Alignment of ", stringify!(SkSurface))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface16MakeRasterDirectERK11SkImageInfoPvmPK14SkSurfaceProps"]
    pub fn SkSurface_MakeRasterDirect(
        imageInfo: *const SkImageInfo,
        pixels: *mut ::std::os::raw::c_void,
        rowBytes: usize,
        surfaceProps: *const SkSurfaceProps,
    ) -> sk_sp<SkSurface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface27MakeRasterDirectReleaseProcERK11SkImageInfoPvmPFvS3_S3_ES3_PK14SkSurfaceProps"]
    pub fn SkSurface_MakeRasterDirectReleaseProc(
        imageInfo: *const SkImageInfo,
        pixels: *mut ::std::os::raw::c_void,
        rowBytes: usize,
        releaseProc: ::core::option::Option<
            unsafe extern "C" fn(
                pixels: *mut ::std::os::raw::c_void,
                context: *mut ::std::os::raw::c_void,
            ),
        >,
        context: *mut ::std::os::raw::c_void,
        surfaceProps: *const SkSurfaceProps,
    ) -> sk_sp<SkSurface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface10MakeRasterERK11SkImageInfomPK14SkSurfaceProps"]
    pub fn SkSurface_MakeRaster(
        imageInfo: *const SkImageInfo,
        rowBytes: usize,
        surfaceProps: *const SkSurfaceProps,
    ) -> sk_sp<SkSurface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface19MakeRasterN32PremulEiiPK14SkSurfaceProps"]
    pub fn SkSurface_MakeRasterN32Premul(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        surfaceProps: *const SkSurfaceProps,
    ) -> sk_sp<SkSurface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface22MakeFromBackendTextureEP9GrContextRK16GrBackendTexture15GrSurfaceOrigini11SkColorType5sk_spI12SkColorSpaceEPK14SkSurfacePropsPFvPvESD_"]
    pub fn SkSurface_MakeFromBackendTexture(
        context: *mut GrContext,
        backendTexture: *const GrBackendTexture,
        origin: GrSurfaceOrigin,
        sampleCnt: ::std::os::raw::c_int,
        colorType: SkColorType,
        colorSpace: sk_sp<SkColorSpace>,
        surfaceProps: *const SkSurfaceProps,
        textureReleaseProc: SkSurface_TextureReleaseProc,
        releaseContext: SkSurface_ReleaseContext,
    ) -> sk_sp<SkSurface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface27MakeFromBackendRenderTargetEP9GrContextRK21GrBackendRenderTarget15GrSurfaceOrigin11SkColorType5sk_spI12SkColorSpaceEPK14SkSurfacePropsPFvPvESD_"]
    pub fn SkSurface_MakeFromBackendRenderTarget(
        context: *mut GrContext,
        backendRenderTarget: *const GrBackendRenderTarget,
        origin: GrSurfaceOrigin,
        colorType: SkColorType,
        colorSpace: sk_sp<SkColorSpace>,
        surfaceProps: *const SkSurfaceProps,
        releaseProc: SkSurface_RenderTargetReleaseProc,
        releaseContext: SkSurface_ReleaseContext,
    ) -> sk_sp<SkSurface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface36MakeFromBackendTextureAsRenderTargetEP9GrContextRK16GrBackendTexture15GrSurfaceOrigini11SkColorType5sk_spI12SkColorSpaceEPK14SkSurfaceProps"]
    pub fn SkSurface_MakeFromBackendTextureAsRenderTarget(
        context: *mut GrContext,
        backendTexture: *const GrBackendTexture,
        origin: GrSurfaceOrigin,
        sampleCnt: ::std::os::raw::c_int,
        colorType: SkColorType,
        colorSpace: sk_sp<SkColorSpace>,
        surfaceProps: *const SkSurfaceProps,
    ) -> sk_sp<SkSurface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface16MakeRenderTargetEP9GrContext10SkBudgetedRK11SkImageInfoi15GrSurfaceOriginPK14SkSurfacePropsb"]
    pub fn SkSurface_MakeRenderTarget(
        context: *mut GrContext,
        budgeted: SkBudgeted,
        imageInfo: *const SkImageInfo,
        sampleCount: ::std::os::raw::c_int,
        surfaceOrigin: GrSurfaceOrigin,
        surfaceProps: *const SkSurfaceProps,
        shouldCreateWithMips: bool,
    ) -> sk_sp<SkSurface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface16MakeRenderTargetEP18GrRecordingContextRK25SkSurfaceCharacterization10SkBudgeted"]
    pub fn SkSurface_MakeRenderTarget1(
        context: *mut GrRecordingContext,
        characterization: *const SkSurfaceCharacterization,
        budgeted: SkBudgeted,
    ) -> sk_sp<SkSurface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface22MakeFromBackendTextureEP9GrContextRK25SkSurfaceCharacterizationRK16GrBackendTexturePFvPvES8_"]
    pub fn SkSurface_MakeFromBackendTexture1(
        context: *mut GrContext,
        characterzation: *const SkSurfaceCharacterization,
        backendTexture: *const GrBackendTexture,
        textureReleaseProc: SkSurface_TextureReleaseProc,
        releaseContext: SkSurface_ReleaseContext,
    ) -> sk_sp<SkSurface>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkSurface12isCompatibleERK25SkSurfaceCharacterization"]
    pub fn SkSurface_isCompatible(
        this: *const SkSurface,
        characterization: *const SkSurfaceCharacterization,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface8MakeNullEii"]
    pub fn SkSurface_MakeNull(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
    ) -> sk_sp<SkSurface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface9imageInfoEv"]
    pub fn SkSurface_imageInfo(this: *mut SkSurface) -> SkImageInfo;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface12generationIDEv"]
    pub fn SkSurface_generationID(this: *mut SkSurface) -> u32;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface23notifyContentWillChangeENS_17ContentChangeModeE"]
    pub fn SkSurface_notifyContentWillChange(
        this: *mut SkSurface,
        mode: SkSurface_ContentChangeMode,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface17getBackendTextureENS_19BackendHandleAccessE"]
    pub fn SkSurface_getBackendTexture(
        this: *mut SkSurface,
        backendHandleAccess: SkSurface_BackendHandleAccess,
    ) -> GrBackendTexture;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface22getBackendRenderTargetENS_19BackendHandleAccessE"]
    pub fn SkSurface_getBackendRenderTarget(
        this: *mut SkSurface,
        backendHandleAccess: SkSurface_BackendHandleAccess,
    ) -> GrBackendRenderTarget;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface21replaceBackendTextureERK16GrBackendTexture15GrSurfaceOriginPFvPvES4_"]
    pub fn SkSurface_replaceBackendTexture(
        this: *mut SkSurface,
        backendTexture: *const GrBackendTexture,
        origin: GrSurfaceOrigin,
        textureReleaseProc: SkSurface_TextureReleaseProc,
        releaseContext: SkSurface_ReleaseContext,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface9getCanvasEv"]
    pub fn SkSurface_getCanvas(this: *mut SkSurface) -> *mut SkCanvas;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface11makeSurfaceERK11SkImageInfo"]
    pub fn SkSurface_makeSurface(
        this: *mut SkSurface,
        imageInfo: *const SkImageInfo,
    ) -> sk_sp<SkSurface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface11makeSurfaceEii"]
    pub fn SkSurface_makeSurface1(
        this: *mut SkSurface,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
    ) -> sk_sp<SkSurface>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface17makeImageSnapshotEv"]
    pub fn SkSurface_makeImageSnapshot(this: *mut SkSurface) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface17makeImageSnapshotERK7SkIRect"]
    pub fn SkSurface_makeImageSnapshot1(
        this: *mut SkSurface,
        bounds: *const SkIRect,
    ) -> sk_sp<SkImage>;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface4drawEP8SkCanvasffPK7SkPaint"]
    pub fn SkSurface_draw(
        this: *mut SkSurface,
        canvas: *mut SkCanvas,
        x: SkScalar,
        y: SkScalar,
        paint: *const SkPaint,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface10peekPixelsEP8SkPixmap"]
    pub fn SkSurface_peekPixels(this: *mut SkSurface, pixmap: *mut SkPixmap) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface10readPixelsERK8SkPixmapii"]
    pub fn SkSurface_readPixels(
        this: *mut SkSurface,
        dst: *const SkPixmap,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface10readPixelsERK11SkImageInfoPvmii"]
    pub fn SkSurface_readPixels1(
        this: *mut SkSurface,
        dstInfo: *const SkImageInfo,
        dstPixels: *mut ::std::os::raw::c_void,
        dstRowBytes: usize,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface10readPixelsERK8SkBitmapii"]
    pub fn SkSurface_readPixels2(
        this: *mut SkSurface,
        dst: *const SkBitmap,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface25asyncRescaleAndReadPixelsERK11SkImageInfoRK7SkIRectNS_12RescaleGammaE15SkFilterQualityPFvPvPKvmES8_"]
    pub fn SkSurface_asyncRescaleAndReadPixels(
        this: *mut SkSurface,
        info: *const SkImageInfo,
        srcRect: *const SkIRect,
        rescaleGamma: SkSurface_RescaleGamma,
        rescaleQuality: SkFilterQuality,
        callback: SkSurface_ReadPixelsCallback,
        context: SkSurface_ReadPixelsContext,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface31asyncRescaleAndReadPixelsYUV420E15SkYUVColorSpace5sk_spI12SkColorSpaceERK7SkIRectiiNS_12RescaleGammaE15SkFilterQualityPFvPvPPKvPmES9_"]
    pub fn SkSurface_asyncRescaleAndReadPixelsYUV420(
        this: *mut SkSurface,
        yuvColorSpace: SkYUVColorSpace,
        dstColorSpace: sk_sp<SkColorSpace>,
        srcRect: *const SkIRect,
        dstW: ::std::os::raw::c_int,
        dstH: ::std::os::raw::c_int,
        rescaleGamma: SkSurface_RescaleGamma,
        rescaleQuality: SkFilterQuality,
        callback: SkSurface_ReadPixelsCallbackYUV420,
        arg1: SkSurface_ReadPixelsContext,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface11writePixelsERK8SkPixmapii"]
    pub fn SkSurface_writePixels(
        this: *mut SkSurface,
        src: *const SkPixmap,
        dstX: ::std::os::raw::c_int,
        dstY: ::std::os::raw::c_int,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface11writePixelsERK8SkBitmapii"]
    pub fn SkSurface_writePixels1(
        this: *mut SkSurface,
        src: *const SkBitmap,
        dstX: ::std::os::raw::c_int,
        dstY: ::std::os::raw::c_int,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface5flushEv"]
    pub fn SkSurface_flush(this: *mut SkSurface);
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface5flushENS_20BackendSurfaceAccessERK11GrFlushInfo"]
    pub fn SkSurface_flush1(
        this: *mut SkSurface,
        access: SkSurface_BackendSurfaceAccess,
        info: *const GrFlushInfo,
    ) -> GrSemaphoresSubmitted;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface5flushENS_20BackendSurfaceAccessE12GrFlushFlagsiP18GrBackendSemaphorePFvPvES4_"]
    pub fn SkSurface_flush2(
        this: *mut SkSurface,
        access: SkSurface_BackendSurfaceAccess,
        flags: GrFlushFlags,
        numSemaphores: ::std::os::raw::c_int,
        signalSemaphores: *mut GrBackendSemaphore,
        finishedProc: GrGpuFinishedProc,
        finishedContext: GrGpuFinishedContext,
    ) -> GrSemaphoresSubmitted;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface5flushENS_20BackendSurfaceAccessENS_10FlushFlagsEiP18GrBackendSemaphore"]
    pub fn SkSurface_flush3(
        this: *mut SkSurface,
        access: SkSurface_BackendSurfaceAccess,
        flags: SkSurface_FlushFlags,
        numSemaphores: ::std::os::raw::c_int,
        signalSemaphores: *mut GrBackendSemaphore,
    ) -> GrSemaphoresSubmitted;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface24flushAndSignalSemaphoresEiP18GrBackendSemaphore"]
    pub fn SkSurface_flushAndSignalSemaphores(
        this: *mut SkSurface,
        numSemaphores: ::std::os::raw::c_int,
        signalSemaphores: *mut GrBackendSemaphore,
    ) -> GrSemaphoresSubmitted;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface4waitEiPK18GrBackendSemaphore"]
    pub fn SkSurface_wait(
        this: *mut SkSurface,
        numSemaphores: ::std::os::raw::c_int,
        waitSemaphores: *const GrBackendSemaphore,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkSurface12characterizeEP25SkSurfaceCharacterization"]
    pub fn SkSurface_characterize(
        this: *const SkSurface,
        characterization: *mut SkSurfaceCharacterization,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface4drawEP21SkDeferredDisplayList"]
    pub fn SkSurface_draw1(
        this: *mut SkSurface,
        deferredDisplayList: *mut SkDeferredDisplayList,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurfaceC1EiiPK14SkSurfaceProps"]
    pub fn SkSurface_SkSurface(
        this: *mut SkSurface,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        surfaceProps: *const SkSurfaceProps,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurfaceC1ERK11SkImageInfoPK14SkSurfaceProps"]
    pub fn SkSurface_SkSurface1(
        this: *mut SkSurface,
        imageInfo: *const SkImageInfo,
        surfaceProps: *const SkSurfaceProps,
    );
}
impl SkSurface {
    #[inline]
    pub unsafe fn MakeRasterDirect(
        imageInfo: *const SkImageInfo,
        pixels: *mut ::std::os::raw::c_void,
        rowBytes: usize,
        surfaceProps: *const SkSurfaceProps,
    ) -> sk_sp<SkSurface> {
        SkSurface_MakeRasterDirect(imageInfo, pixels, rowBytes, surfaceProps)
    }
    #[inline]
    pub unsafe fn MakeRasterDirectReleaseProc(
        imageInfo: *const SkImageInfo,
        pixels: *mut ::std::os::raw::c_void,
        rowBytes: usize,
        releaseProc: ::core::option::Option<
            unsafe extern "C" fn(
                pixels: *mut ::std::os::raw::c_void,
                context: *mut ::std::os::raw::c_void,
            ),
        >,
        context: *mut ::std::os::raw::c_void,
        surfaceProps: *const SkSurfaceProps,
    ) -> sk_sp<SkSurface> {
        SkSurface_MakeRasterDirectReleaseProc(
            imageInfo,
            pixels,
            rowBytes,
            releaseProc,
            context,
            surfaceProps,
        )
    }
    #[inline]
    pub unsafe fn MakeRaster(
        imageInfo: *const SkImageInfo,
        rowBytes: usize,
        surfaceProps: *const SkSurfaceProps,
    ) -> sk_sp<SkSurface> {
        SkSurface_MakeRaster(imageInfo, rowBytes, surfaceProps)
    }
    #[inline]
    pub unsafe fn MakeRasterN32Premul(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        surfaceProps: *const SkSurfaceProps,
    ) -> sk_sp<SkSurface> {
        SkSurface_MakeRasterN32Premul(width, height, surfaceProps)
    }
    #[inline]
    pub unsafe fn MakeFromBackendTexture(
        context: *mut GrContext,
        backendTexture: *const GrBackendTexture,
        origin: GrSurfaceOrigin,
        sampleCnt: ::std::os::raw::c_int,
        colorType: SkColorType,
        colorSpace: sk_sp<SkColorSpace>,
        surfaceProps: *const SkSurfaceProps,
        textureReleaseProc: SkSurface_TextureReleaseProc,
        releaseContext: SkSurface_ReleaseContext,
    ) -> sk_sp<SkSurface> {
        SkSurface_MakeFromBackendTexture(
            context,
            backendTexture,
            origin,
            sampleCnt,
            colorType,
            colorSpace,
            surfaceProps,
            textureReleaseProc,
            releaseContext,
        )
    }
    #[inline]
    pub unsafe fn MakeFromBackendRenderTarget(
        context: *mut GrContext,
        backendRenderTarget: *const GrBackendRenderTarget,
        origin: GrSurfaceOrigin,
        colorType: SkColorType,
        colorSpace: sk_sp<SkColorSpace>,
        surfaceProps: *const SkSurfaceProps,
        releaseProc: SkSurface_RenderTargetReleaseProc,
        releaseContext: SkSurface_ReleaseContext,
    ) -> sk_sp<SkSurface> {
        SkSurface_MakeFromBackendRenderTarget(
            context,
            backendRenderTarget,
            origin,
            colorType,
            colorSpace,
            surfaceProps,
            releaseProc,
            releaseContext,
        )
    }
    #[inline]
    pub unsafe fn MakeFromBackendTextureAsRenderTarget(
        context: *mut GrContext,
        backendTexture: *const GrBackendTexture,
        origin: GrSurfaceOrigin,
        sampleCnt: ::std::os::raw::c_int,
        colorType: SkColorType,
        colorSpace: sk_sp<SkColorSpace>,
        surfaceProps: *const SkSurfaceProps,
    ) -> sk_sp<SkSurface> {
        SkSurface_MakeFromBackendTextureAsRenderTarget(
            context,
            backendTexture,
            origin,
            sampleCnt,
            colorType,
            colorSpace,
            surfaceProps,
        )
    }
    #[inline]
    pub unsafe fn MakeRenderTarget(
        context: *mut GrContext,
        budgeted: SkBudgeted,
        imageInfo: *const SkImageInfo,
        sampleCount: ::std::os::raw::c_int,
        surfaceOrigin: GrSurfaceOrigin,
        surfaceProps: *const SkSurfaceProps,
        shouldCreateWithMips: bool,
    ) -> sk_sp<SkSurface> {
        SkSurface_MakeRenderTarget(
            context,
            budgeted,
            imageInfo,
            sampleCount,
            surfaceOrigin,
            surfaceProps,
            shouldCreateWithMips,
        )
    }
    #[inline]
    pub unsafe fn MakeRenderTarget1(
        context: *mut GrRecordingContext,
        characterization: *const SkSurfaceCharacterization,
        budgeted: SkBudgeted,
    ) -> sk_sp<SkSurface> {
        SkSurface_MakeRenderTarget1(context, characterization, budgeted)
    }
    #[inline]
    pub unsafe fn MakeFromBackendTexture1(
        context: *mut GrContext,
        characterzation: *const SkSurfaceCharacterization,
        backendTexture: *const GrBackendTexture,
        textureReleaseProc: SkSurface_TextureReleaseProc,
        releaseContext: SkSurface_ReleaseContext,
    ) -> sk_sp<SkSurface> {
        SkSurface_MakeFromBackendTexture1(
            context,
            characterzation,
            backendTexture,
            textureReleaseProc,
            releaseContext,
        )
    }
    #[inline]
    pub unsafe fn isCompatible(&self, characterization: *const SkSurfaceCharacterization) -> bool {
        SkSurface_isCompatible(self, characterization)
    }
    #[inline]
    pub unsafe fn MakeNull(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
    ) -> sk_sp<SkSurface> {
        SkSurface_MakeNull(width, height)
    }
    #[inline]
    pub unsafe fn imageInfo(&mut self) -> SkImageInfo {
        SkSurface_imageInfo(self)
    }
    #[inline]
    pub unsafe fn generationID(&mut self) -> u32 {
        SkSurface_generationID(self)
    }
    #[inline]
    pub unsafe fn notifyContentWillChange(&mut self, mode: SkSurface_ContentChangeMode) {
        SkSurface_notifyContentWillChange(self, mode)
    }
    #[inline]
    pub unsafe fn getBackendTexture(
        &mut self,
        backendHandleAccess: SkSurface_BackendHandleAccess,
    ) -> GrBackendTexture {
        SkSurface_getBackendTexture(self, backendHandleAccess)
    }
    #[inline]
    pub unsafe fn getBackendRenderTarget(
        &mut self,
        backendHandleAccess: SkSurface_BackendHandleAccess,
    ) -> GrBackendRenderTarget {
        SkSurface_getBackendRenderTarget(self, backendHandleAccess)
    }
    #[inline]
    pub unsafe fn replaceBackendTexture(
        &mut self,
        backendTexture: *const GrBackendTexture,
        origin: GrSurfaceOrigin,
        textureReleaseProc: SkSurface_TextureReleaseProc,
        releaseContext: SkSurface_ReleaseContext,
    ) -> bool {
        SkSurface_replaceBackendTexture(
            self,
            backendTexture,
            origin,
            textureReleaseProc,
            releaseContext,
        )
    }
    #[inline]
    pub unsafe fn getCanvas(&mut self) -> *mut SkCanvas {
        SkSurface_getCanvas(self)
    }
    #[inline]
    pub unsafe fn makeSurface(&mut self, imageInfo: *const SkImageInfo) -> sk_sp<SkSurface> {
        SkSurface_makeSurface(self, imageInfo)
    }
    #[inline]
    pub unsafe fn makeSurface1(
        &mut self,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
    ) -> sk_sp<SkSurface> {
        SkSurface_makeSurface1(self, width, height)
    }
    #[inline]
    pub unsafe fn makeImageSnapshot(&mut self) -> sk_sp<SkImage> {
        SkSurface_makeImageSnapshot(self)
    }
    #[inline]
    pub unsafe fn makeImageSnapshot1(&mut self, bounds: *const SkIRect) -> sk_sp<SkImage> {
        SkSurface_makeImageSnapshot1(self, bounds)
    }
    #[inline]
    pub unsafe fn draw(
        &mut self,
        canvas: *mut SkCanvas,
        x: SkScalar,
        y: SkScalar,
        paint: *const SkPaint,
    ) {
        SkSurface_draw(self, canvas, x, y, paint)
    }
    #[inline]
    pub unsafe fn peekPixels(&mut self, pixmap: *mut SkPixmap) -> bool {
        SkSurface_peekPixels(self, pixmap)
    }
    #[inline]
    pub unsafe fn readPixels(
        &mut self,
        dst: *const SkPixmap,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
    ) -> bool {
        SkSurface_readPixels(self, dst, srcX, srcY)
    }
    #[inline]
    pub unsafe fn readPixels1(
        &mut self,
        dstInfo: *const SkImageInfo,
        dstPixels: *mut ::std::os::raw::c_void,
        dstRowBytes: usize,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
    ) -> bool {
        SkSurface_readPixels1(self, dstInfo, dstPixels, dstRowBytes, srcX, srcY)
    }
    #[inline]
    pub unsafe fn readPixels2(
        &mut self,
        dst: *const SkBitmap,
        srcX: ::std::os::raw::c_int,
        srcY: ::std::os::raw::c_int,
    ) -> bool {
        SkSurface_readPixels2(self, dst, srcX, srcY)
    }
    #[inline]
    pub unsafe fn asyncRescaleAndReadPixels(
        &mut self,
        info: *const SkImageInfo,
        srcRect: *const SkIRect,
        rescaleGamma: SkSurface_RescaleGamma,
        rescaleQuality: SkFilterQuality,
        callback: SkSurface_ReadPixelsCallback,
        context: SkSurface_ReadPixelsContext,
    ) {
        SkSurface_asyncRescaleAndReadPixels(
            self,
            info,
            srcRect,
            rescaleGamma,
            rescaleQuality,
            callback,
            context,
        )
    }
    #[inline]
    pub unsafe fn asyncRescaleAndReadPixelsYUV420(
        &mut self,
        yuvColorSpace: SkYUVColorSpace,
        dstColorSpace: sk_sp<SkColorSpace>,
        srcRect: *const SkIRect,
        dstW: ::std::os::raw::c_int,
        dstH: ::std::os::raw::c_int,
        rescaleGamma: SkSurface_RescaleGamma,
        rescaleQuality: SkFilterQuality,
        callback: SkSurface_ReadPixelsCallbackYUV420,
        arg1: SkSurface_ReadPixelsContext,
    ) {
        SkSurface_asyncRescaleAndReadPixelsYUV420(
            self,
            yuvColorSpace,
            dstColorSpace,
            srcRect,
            dstW,
            dstH,
            rescaleGamma,
            rescaleQuality,
            callback,
            arg1,
        )
    }
    #[inline]
    pub unsafe fn writePixels(
        &mut self,
        src: *const SkPixmap,
        dstX: ::std::os::raw::c_int,
        dstY: ::std::os::raw::c_int,
    ) {
        SkSurface_writePixels(self, src, dstX, dstY)
    }
    #[inline]
    pub unsafe fn writePixels1(
        &mut self,
        src: *const SkBitmap,
        dstX: ::std::os::raw::c_int,
        dstY: ::std::os::raw::c_int,
    ) {
        SkSurface_writePixels1(self, src, dstX, dstY)
    }
    #[inline]
    pub unsafe fn flush(&mut self) {
        SkSurface_flush(self)
    }
    #[inline]
    pub unsafe fn flush1(
        &mut self,
        access: SkSurface_BackendSurfaceAccess,
        info: *const GrFlushInfo,
    ) -> GrSemaphoresSubmitted {
        SkSurface_flush1(self, access, info)
    }
    #[inline]
    pub unsafe fn flush2(
        &mut self,
        access: SkSurface_BackendSurfaceAccess,
        flags: GrFlushFlags,
        numSemaphores: ::std::os::raw::c_int,
        signalSemaphores: *mut GrBackendSemaphore,
        finishedProc: GrGpuFinishedProc,
        finishedContext: GrGpuFinishedContext,
    ) -> GrSemaphoresSubmitted {
        SkSurface_flush2(
            self,
            access,
            flags,
            numSemaphores,
            signalSemaphores,
            finishedProc,
            finishedContext,
        )
    }
    #[inline]
    pub unsafe fn flush3(
        &mut self,
        access: SkSurface_BackendSurfaceAccess,
        flags: SkSurface_FlushFlags,
        numSemaphores: ::std::os::raw::c_int,
        signalSemaphores: *mut GrBackendSemaphore,
    ) -> GrSemaphoresSubmitted {
        SkSurface_flush3(self, access, flags, numSemaphores, signalSemaphores)
    }
    #[inline]
    pub unsafe fn flushAndSignalSemaphores(
        &mut self,
        numSemaphores: ::std::os::raw::c_int,
        signalSemaphores: *mut GrBackendSemaphore,
    ) -> GrSemaphoresSubmitted {
        SkSurface_flushAndSignalSemaphores(self, numSemaphores, signalSemaphores)
    }
    #[inline]
    pub unsafe fn wait(
        &mut self,
        numSemaphores: ::std::os::raw::c_int,
        waitSemaphores: *const GrBackendSemaphore,
    ) -> bool {
        SkSurface_wait(self, numSemaphores, waitSemaphores)
    }
    #[inline]
    pub unsafe fn characterize(&self, characterization: *mut SkSurfaceCharacterization) -> bool {
        SkSurface_characterize(self, characterization)
    }
    #[inline]
    pub unsafe fn draw1(&mut self, deferredDisplayList: *mut SkDeferredDisplayList) -> bool {
        SkSurface_draw1(self, deferredDisplayList)
    }
    #[inline]
    pub unsafe fn new(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        surfaceProps: *const SkSurfaceProps,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkSurface_SkSurface(&mut __bindgen_tmp, width, height, surfaceProps);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(imageInfo: *const SkImageInfo, surfaceProps: *const SkSurfaceProps) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkSurface_SkSurface1(&mut __bindgen_tmp, imageInfo, surfaceProps);
        __bindgen_tmp
    }
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface30kFlushRead_TextureHandleAccessE"]
    pub static SkSurface_kFlushRead_TextureHandleAccess: SkSurface_BackendHandleAccess;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface31kFlushWrite_TextureHandleAccessE"]
    pub static SkSurface_kFlushWrite_TextureHandleAccess: SkSurface_BackendHandleAccess;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkSurface33kDiscardWrite_TextureHandleAccessE"]
    pub static SkSurface_kDiscardWrite_TextureHandleAccess: SkSurface_BackendHandleAccess;
}
extern "C" {
    #[link_name = "\u{1}_Z8SkSwapRBPjPKji"]
    pub fn SkSwapRB(dest: *mut u32, src: *const u32, count: ::std::os::raw::c_int);
}
#[repr(C)]
pub struct SkTextBlob {
    pub _base: SkNVRefCnt,
    pub fBounds: SkRect,
    pub fUniqueID: u32,
    pub fCacheID: u32,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkTextBlob_RunRecord {
    _unused: [u8; 0],
}
#[repr(u8)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkTextBlob_GlyphPositioning {
    __bindgen_cannot_repr_c_on_empty_enum = 0,
}
pub type SkTextBlob_INHERITED = SkRefCnt;
#[test]
fn bindgen_test_layout_SkTextBlob() {
    assert_eq!(
        ::core::mem::size_of::<SkTextBlob>(),
        28usize,
        concat!("Size of: ", stringify!(SkTextBlob))
    );
    assert_eq!(
        ::core::mem::align_of::<SkTextBlob>(),
        4usize,
        concat!("Alignment of ", stringify!(SkTextBlob))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTextBlob>())).fBounds as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTextBlob),
            "::",
            stringify!(fBounds)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTextBlob>())).fUniqueID as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTextBlob),
            "::",
            stringify!(fUniqueID)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTextBlob>())).fCacheID as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTextBlob),
            "::",
            stringify!(fCacheID)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTextBlob13getInterceptsEPKfPfPK7SkPaint"]
    pub fn SkTextBlob_getIntercepts(
        this: *const SkTextBlob,
        bounds: *const SkScalar,
        intervals: *mut SkScalar,
        paint: *const SkPaint,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkTextBlob12MakeFromTextEPKvmRK6SkFont14SkTextEncoding"]
    pub fn SkTextBlob_MakeFromText(
        text: *const ::std::os::raw::c_void,
        byteLength: usize,
        font: *const SkFont,
        encoding: SkTextEncoding,
    ) -> sk_sp<SkTextBlob>;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkTextBlob16MakeFromPosTextHEPKvmPKffRK6SkFont14SkTextEncoding"]
    pub fn SkTextBlob_MakeFromPosTextH(
        text: *const ::std::os::raw::c_void,
        byteLength: usize,
        xpos: *const SkScalar,
        constY: SkScalar,
        font: *const SkFont,
        encoding: SkTextEncoding,
    ) -> sk_sp<SkTextBlob>;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkTextBlob15MakeFromPosTextEPKvmPK7SkPointRK6SkFont14SkTextEncoding"]
    pub fn SkTextBlob_MakeFromPosText(
        text: *const ::std::os::raw::c_void,
        byteLength: usize,
        pos: *const SkPoint,
        font: *const SkFont,
        encoding: SkTextEncoding,
    ) -> sk_sp<SkTextBlob>;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkTextBlob15MakeFromRSXformEPKvmPK9SkRSXformRK6SkFont14SkTextEncoding"]
    pub fn SkTextBlob_MakeFromRSXform(
        text: *const ::std::os::raw::c_void,
        byteLength: usize,
        xform: *const SkRSXform,
        font: *const SkFont,
        encoding: SkTextEncoding,
    ) -> sk_sp<SkTextBlob>;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTextBlob9serializeERK13SkSerialProcsPvm"]
    pub fn SkTextBlob_serialize(
        this: *const SkTextBlob,
        procs: *const SkSerialProcs,
        memory: *mut ::std::os::raw::c_void,
        memory_size: usize,
    ) -> usize;
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkTextBlob9serializeERK13SkSerialProcs"]
    pub fn SkTextBlob_serialize1(
        this: *const SkTextBlob,
        procs: *const SkSerialProcs,
    ) -> sk_sp<SkData>;
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkTextBlob11DeserializeEPKvmRK15SkDeserialProcs"]
    pub fn SkTextBlob_Deserialize(
        data: *const ::std::os::raw::c_void,
        size: usize,
        procs: *const SkDeserialProcs,
    ) -> sk_sp<SkTextBlob>;
}
impl SkTextBlob {
    #[inline]
    pub unsafe fn getIntercepts(
        &self,
        bounds: *const SkScalar,
        intervals: *mut SkScalar,
        paint: *const SkPaint,
    ) -> ::std::os::raw::c_int {
        SkTextBlob_getIntercepts(self, bounds, intervals, paint)
    }
    #[inline]
    pub unsafe fn MakeFromText(
        text: *const ::std::os::raw::c_void,
        byteLength: usize,
        font: *const SkFont,
        encoding: SkTextEncoding,
    ) -> sk_sp<SkTextBlob> {
        SkTextBlob_MakeFromText(text, byteLength, font, encoding)
    }
    #[inline]
    pub unsafe fn MakeFromPosTextH(
        text: *const ::std::os::raw::c_void,
        byteLength: usize,
        xpos: *const SkScalar,
        constY: SkScalar,
        font: *const SkFont,
        encoding: SkTextEncoding,
    ) -> sk_sp<SkTextBlob> {
        SkTextBlob_MakeFromPosTextH(text, byteLength, xpos, constY, font, encoding)
    }
    #[inline]
    pub unsafe fn MakeFromPosText(
        text: *const ::std::os::raw::c_void,
        byteLength: usize,
        pos: *const SkPoint,
        font: *const SkFont,
        encoding: SkTextEncoding,
    ) -> sk_sp<SkTextBlob> {
        SkTextBlob_MakeFromPosText(text, byteLength, pos, font, encoding)
    }
    #[inline]
    pub unsafe fn MakeFromRSXform(
        text: *const ::std::os::raw::c_void,
        byteLength: usize,
        xform: *const SkRSXform,
        font: *const SkFont,
        encoding: SkTextEncoding,
    ) -> sk_sp<SkTextBlob> {
        SkTextBlob_MakeFromRSXform(text, byteLength, xform, font, encoding)
    }
    #[inline]
    pub unsafe fn serialize(
        &self,
        procs: *const SkSerialProcs,
        memory: *mut ::std::os::raw::c_void,
        memory_size: usize,
    ) -> usize {
        SkTextBlob_serialize(self, procs, memory, memory_size)
    }
    #[inline]
    pub unsafe fn serialize1(&self, procs: *const SkSerialProcs) -> sk_sp<SkData> {
        SkTextBlob_serialize1(self, procs)
    }
    #[inline]
    pub unsafe fn Deserialize(
        data: *const ::std::os::raw::c_void,
        size: usize,
        procs: *const SkDeserialProcs,
    ) -> sk_sp<SkTextBlob> {
        SkTextBlob_Deserialize(data, size, procs)
    }
}
#[repr(C)]
pub struct SkTextBlobBuilder {
    pub fStorage: u64,
    pub fStorageSize: usize,
    pub fStorageUsed: usize,
    pub fBounds: SkRect,
    pub fRunCount: ::std::os::raw::c_int,
    pub fDeferredBounds: bool,
    pub fLastRun: usize,
    pub fCurrentRunBuffer: SkTextBlobBuilder_RunBuffer,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkTextBlobBuilder_RunBuffer {
    pub glyphs: *mut SkGlyphID,
    pub pos: *mut SkScalar,
    pub utf8text: *mut ::std::os::raw::c_char,
    pub clusters: *mut u32,
}
#[test]
fn bindgen_test_layout_SkTextBlobBuilder_RunBuffer() {
    assert_eq!(
        ::core::mem::size_of::<SkTextBlobBuilder_RunBuffer>(),
        32usize,
        concat!("Size of: ", stringify!(SkTextBlobBuilder_RunBuffer))
    );
    assert_eq!(
        ::core::mem::align_of::<SkTextBlobBuilder_RunBuffer>(),
        8usize,
        concat!("Alignment of ", stringify!(SkTextBlobBuilder_RunBuffer))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkTextBlobBuilder_RunBuffer>())).glyphs as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTextBlobBuilder_RunBuffer),
            "::",
            stringify!(glyphs)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkTextBlobBuilder_RunBuffer>())).pos as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTextBlobBuilder_RunBuffer),
            "::",
            stringify!(pos)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkTextBlobBuilder_RunBuffer>())).utf8text as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTextBlobBuilder_RunBuffer),
            "::",
            stringify!(utf8text)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkTextBlobBuilder_RunBuffer>())).clusters as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTextBlobBuilder_RunBuffer),
            "::",
            stringify!(clusters)
        )
    );
}
#[test]
fn bindgen_test_layout_SkTextBlobBuilder() {
    assert_eq!(
        ::core::mem::size_of::<SkTextBlobBuilder>(),
        88usize,
        concat!("Size of: ", stringify!(SkTextBlobBuilder))
    );
    assert_eq!(
        ::core::mem::align_of::<SkTextBlobBuilder>(),
        8usize,
        concat!("Alignment of ", stringify!(SkTextBlobBuilder))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTextBlobBuilder>())).fStorage as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTextBlobBuilder),
            "::",
            stringify!(fStorage)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTextBlobBuilder>())).fStorageSize as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTextBlobBuilder),
            "::",
            stringify!(fStorageSize)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTextBlobBuilder>())).fStorageUsed as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTextBlobBuilder),
            "::",
            stringify!(fStorageUsed)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTextBlobBuilder>())).fBounds as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTextBlobBuilder),
            "::",
            stringify!(fBounds)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTextBlobBuilder>())).fRunCount as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTextBlobBuilder),
            "::",
            stringify!(fRunCount)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkTextBlobBuilder>())).fDeferredBounds as *const _ as usize
        },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTextBlobBuilder),
            "::",
            stringify!(fDeferredBounds)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTextBlobBuilder>())).fLastRun as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTextBlobBuilder),
            "::",
            stringify!(fLastRun)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkTextBlobBuilder>())).fCurrentRunBuffer as *const _ as usize
        },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTextBlobBuilder),
            "::",
            stringify!(fCurrentRunBuffer)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkTextBlobBuilder4makeEv"]
    pub fn SkTextBlobBuilder_make(this: *mut SkTextBlobBuilder) -> sk_sp<SkTextBlob>;
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkTextBlobBuilder8allocRunERK6SkFontiffPK6SkRect"]
    pub fn SkTextBlobBuilder_allocRun(
        this: *mut SkTextBlobBuilder,
        font: *const SkFont,
        count: ::std::os::raw::c_int,
        x: SkScalar,
        y: SkScalar,
        bounds: *const SkRect,
    ) -> *const SkTextBlobBuilder_RunBuffer;
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkTextBlobBuilder12allocRunPosHERK6SkFontifPK6SkRect"]
    pub fn SkTextBlobBuilder_allocRunPosH(
        this: *mut SkTextBlobBuilder,
        font: *const SkFont,
        count: ::std::os::raw::c_int,
        y: SkScalar,
        bounds: *const SkRect,
    ) -> *const SkTextBlobBuilder_RunBuffer;
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkTextBlobBuilder11allocRunPosERK6SkFontiPK6SkRect"]
    pub fn SkTextBlobBuilder_allocRunPos(
        this: *mut SkTextBlobBuilder,
        font: *const SkFont,
        count: ::std::os::raw::c_int,
        bounds: *const SkRect,
    ) -> *const SkTextBlobBuilder_RunBuffer;
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkTextBlobBuilder15allocRunRSXformERK6SkFonti"]
    pub fn SkTextBlobBuilder_allocRunRSXform(
        this: *mut SkTextBlobBuilder,
        font: *const SkFont,
        count: ::std::os::raw::c_int,
    ) -> *const SkTextBlobBuilder_RunBuffer;
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkTextBlobBuilderC1Ev"]
    pub fn SkTextBlobBuilder_SkTextBlobBuilder(this: *mut SkTextBlobBuilder);
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkTextBlobBuilderD1Ev"]
    pub fn SkTextBlobBuilder_SkTextBlobBuilder_destructor(this: *mut SkTextBlobBuilder);
}
impl SkTextBlobBuilder {
    #[inline]
    pub unsafe fn make(&mut self) -> sk_sp<SkTextBlob> {
        SkTextBlobBuilder_make(self)
    }
    #[inline]
    pub unsafe fn allocRun(
        &mut self,
        font: *const SkFont,
        count: ::std::os::raw::c_int,
        x: SkScalar,
        y: SkScalar,
        bounds: *const SkRect,
    ) -> *const SkTextBlobBuilder_RunBuffer {
        SkTextBlobBuilder_allocRun(self, font, count, x, y, bounds)
    }
    #[inline]
    pub unsafe fn allocRunPosH(
        &mut self,
        font: *const SkFont,
        count: ::std::os::raw::c_int,
        y: SkScalar,
        bounds: *const SkRect,
    ) -> *const SkTextBlobBuilder_RunBuffer {
        SkTextBlobBuilder_allocRunPosH(self, font, count, y, bounds)
    }
    #[inline]
    pub unsafe fn allocRunPos(
        &mut self,
        font: *const SkFont,
        count: ::std::os::raw::c_int,
        bounds: *const SkRect,
    ) -> *const SkTextBlobBuilder_RunBuffer {
        SkTextBlobBuilder_allocRunPos(self, font, count, bounds)
    }
    #[inline]
    pub unsafe fn allocRunRSXform(
        &mut self,
        font: *const SkFont,
        count: ::std::os::raw::c_int,
    ) -> *const SkTextBlobBuilder_RunBuffer {
        SkTextBlobBuilder_allocRunRSXform(self, font, count)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkTextBlobBuilder_SkTextBlobBuilder(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        SkTextBlobBuilder_SkTextBlobBuilder_destructor(self)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkTime_DateTime {
    pub fTimeZoneMinutes: i16,
    pub fYear: u16,
    pub fMonth: u8,
    pub fDayOfWeek: u8,
    pub fDay: u8,
    pub fHour: u8,
    pub fMinute: u8,
    pub fSecond: u8,
}
#[test]
fn bindgen_test_layout_SkTime_DateTime() {
    assert_eq!(
        ::core::mem::size_of::<SkTime_DateTime>(),
        10usize,
        concat!("Size of: ", stringify!(SkTime_DateTime))
    );
    assert_eq!(
        ::core::mem::align_of::<SkTime_DateTime>(),
        2usize,
        concat!("Alignment of ", stringify!(SkTime_DateTime))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkTime_DateTime>())).fTimeZoneMinutes as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTime_DateTime),
            "::",
            stringify!(fTimeZoneMinutes)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTime_DateTime>())).fYear as *const _ as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTime_DateTime),
            "::",
            stringify!(fYear)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTime_DateTime>())).fMonth as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTime_DateTime),
            "::",
            stringify!(fMonth)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTime_DateTime>())).fDayOfWeek as *const _ as usize },
        5usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTime_DateTime),
            "::",
            stringify!(fDayOfWeek)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTime_DateTime>())).fDay as *const _ as usize },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTime_DateTime),
            "::",
            stringify!(fDay)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTime_DateTime>())).fHour as *const _ as usize },
        7usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTime_DateTime),
            "::",
            stringify!(fHour)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTime_DateTime>())).fMinute as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTime_DateTime),
            "::",
            stringify!(fMinute)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkTime_DateTime>())).fSecond as *const _ as usize },
        9usize,
        concat!(
            "Offset of field: ",
            stringify!(SkTime_DateTime),
            "::",
            stringify!(fSecond)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK6SkTime8DateTime9toISO8601EP8SkString"]
    pub fn SkTime_DateTime_toISO8601(this: *const SkTime_DateTime, dst: *mut SkString);
}
impl SkTime_DateTime {
    #[inline]
    pub unsafe fn toISO8601(&self, dst: *mut SkString) {
        SkTime_DateTime_toISO8601(self, dst)
    }
}
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkPDF_DocumentStructureType {
    kDocument = 0,
    kPart = 1,
    kArt = 2,
    kSect = 3,
    kDiv = 4,
    kBlockQuote = 5,
    kCaption = 6,
    kTOC = 7,
    kTOCI = 8,
    kIndex = 9,
    kNonStruct = 10,
    kPrivate = 11,
    kH = 12,
    kH1 = 13,
    kH2 = 14,
    kH3 = 15,
    kH4 = 16,
    kH5 = 17,
    kH6 = 18,
    kP = 19,
    kL = 20,
    kLI = 21,
    kLbl = 22,
    kLBody = 23,
    kTable = 24,
    kTR = 25,
    kTH = 26,
    kTD = 27,
    kTHead = 28,
    kTBody = 29,
    kTFoot = 30,
    kSpan = 31,
    kQuote = 32,
    kNote = 33,
    kReference = 34,
    kBibEntry = 35,
    kCode = 36,
    kLink = 37,
    kAnnot = 38,
    kRuby = 39,
    kRB = 40,
    kRT = 41,
    kRP = 42,
    kWarichu = 43,
    kWT = 44,
    kWP = 45,
    kFigure = 46,
    kFormula = 47,
    kForm = 48,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkPDF_StructureElementNode {
    pub fChildren: *const SkPDF_StructureElementNode,
    pub fChildCount: usize,
    pub fNodeId: ::std::os::raw::c_int,
    pub fType: SkPDF_DocumentStructureType,
}
#[test]
fn bindgen_test_layout_SkPDF_StructureElementNode() {
    assert_eq!(
        ::core::mem::size_of::<SkPDF_StructureElementNode>(),
        24usize,
        concat!("Size of: ", stringify!(SkPDF_StructureElementNode))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPDF_StructureElementNode>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPDF_StructureElementNode))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkPDF_StructureElementNode>())).fChildren as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPDF_StructureElementNode),
            "::",
            stringify!(fChildren)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkPDF_StructureElementNode>())).fChildCount as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPDF_StructureElementNode),
            "::",
            stringify!(fChildCount)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkPDF_StructureElementNode>())).fNodeId as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPDF_StructureElementNode),
            "::",
            stringify!(fNodeId)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkPDF_StructureElementNode>())).fType as *const _ as usize
        },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPDF_StructureElementNode),
            "::",
            stringify!(fType)
        )
    );
}
#[repr(C)]
pub struct SkPDF_Metadata {
    pub fTitle: SkString,
    pub fAuthor: SkString,
    pub fSubject: SkString,
    pub fKeywords: SkString,
    pub fCreator: SkString,
    pub fProducer: SkString,
    pub fCreation: SkTime_DateTime,
    pub fModified: SkTime_DateTime,
    pub fRasterDPI: SkScalar,
    pub fPDFA: bool,
    pub fEncodingQuality: ::std::os::raw::c_int,
    pub fStructureElementTreeRoot: *const SkPDF_StructureElementNode,
    pub fExecutor: *mut SkExecutor,
    pub fSubsetter: SkPDF_Metadata_Subsetter,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkPDF_Metadata_Subsetter {
    kHarfbuzz_Subsetter = 0,
    kSfntly_Subsetter = 1,
}
#[test]
fn bindgen_test_layout_SkPDF_Metadata() {
    assert_eq!(
        ::core::mem::size_of::<SkPDF_Metadata>(),
        104usize,
        concat!("Size of: ", stringify!(SkPDF_Metadata))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPDF_Metadata>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPDF_Metadata))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPDF_Metadata>())).fTitle as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPDF_Metadata),
            "::",
            stringify!(fTitle)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPDF_Metadata>())).fAuthor as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPDF_Metadata),
            "::",
            stringify!(fAuthor)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPDF_Metadata>())).fSubject as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPDF_Metadata),
            "::",
            stringify!(fSubject)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPDF_Metadata>())).fKeywords as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPDF_Metadata),
            "::",
            stringify!(fKeywords)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPDF_Metadata>())).fCreator as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPDF_Metadata),
            "::",
            stringify!(fCreator)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPDF_Metadata>())).fProducer as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPDF_Metadata),
            "::",
            stringify!(fProducer)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPDF_Metadata>())).fCreation as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPDF_Metadata),
            "::",
            stringify!(fCreation)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPDF_Metadata>())).fModified as *const _ as usize },
        58usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPDF_Metadata),
            "::",
            stringify!(fModified)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPDF_Metadata>())).fRasterDPI as *const _ as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPDF_Metadata),
            "::",
            stringify!(fRasterDPI)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPDF_Metadata>())).fPDFA as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPDF_Metadata),
            "::",
            stringify!(fPDFA)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkPDF_Metadata>())).fEncodingQuality as *const _ as usize
        },
        76usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPDF_Metadata),
            "::",
            stringify!(fEncodingQuality)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkPDF_Metadata>())).fStructureElementTreeRoot as *const _
                as usize
        },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPDF_Metadata),
            "::",
            stringify!(fStructureElementTreeRoot)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPDF_Metadata>())).fExecutor as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPDF_Metadata),
            "::",
            stringify!(fExecutor)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPDF_Metadata>())).fSubsetter as *const _ as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPDF_Metadata),
            "::",
            stringify!(fSubsetter)
        )
    );
}
#[repr(C)]
pub struct Sk1DPathEffect {
    pub _base: SkPathEffect,
}
pub type Sk1DPathEffect_INHERITED = SkPathEffect;
#[test]
fn bindgen_test_layout_Sk1DPathEffect() {
    assert_eq!(
        ::core::mem::size_of::<Sk1DPathEffect>(),
        16usize,
        concat!("Size of: ", stringify!(Sk1DPathEffect))
    );
    assert_eq!(
        ::core::mem::align_of::<Sk1DPathEffect>(),
        8usize,
        concat!("Alignment of ", stringify!(Sk1DPathEffect))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK14Sk1DPathEffect12onFilterPathEP6SkPathRKS0_P11SkStrokeRecPK6SkRect"]
    pub fn Sk1DPathEffect_onFilterPath(
        this: *mut ::std::os::raw::c_void,
        dst: *mut SkPath,
        src: *const SkPath,
        arg1: *mut SkStrokeRec,
        arg2: *const SkRect,
    ) -> bool;
}
#[repr(C)]
pub struct SkPath1DPathEffect {
    pub _base: Sk1DPathEffect,
    pub fPath: SkPath,
    pub fAdvance: SkScalar,
    pub fInitialOffset: SkScalar,
    pub fStyle: SkPath1DPathEffect_Style,
}
impl SkPath1DPathEffect_Style {
    pub const kLastEnum_Style: SkPath1DPathEffect_Style = SkPath1DPathEffect_Style::kMorph_Style;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkPath1DPathEffect_Style {
    kTranslate_Style = 0,
    kRotate_Style = 1,
    kMorph_Style = 2,
}
pub type SkPath1DPathEffect_INHERITED = Sk1DPathEffect;
#[test]
fn bindgen_test_layout_SkPath1DPathEffect() {
    assert_eq!(
        ::core::mem::size_of::<SkPath1DPathEffect>(),
        48usize,
        concat!("Size of: ", stringify!(SkPath1DPathEffect))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPath1DPathEffect>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPath1DPathEffect))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPath1DPathEffect>())).fPath as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPath1DPathEffect),
            "::",
            stringify!(fPath)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPath1DPathEffect>())).fAdvance as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPath1DPathEffect),
            "::",
            stringify!(fAdvance)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkPath1DPathEffect>())).fInitialOffset as *const _ as usize
        },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPath1DPathEffect),
            "::",
            stringify!(fInitialOffset)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPath1DPathEffect>())).fStyle as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPath1DPathEffect),
            "::",
            stringify!(fStyle)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN18SkPath1DPathEffect4MakeERK6SkPathffNS_5StyleE"]
    pub fn SkPath1DPathEffect_Make(
        path: *const SkPath,
        advance: SkScalar,
        phase: SkScalar,
        arg1: SkPath1DPathEffect_Style,
    ) -> sk_sp<SkPathEffect>;
}
extern "C" {
    #[link_name = "\u{1}_ZN18SkPath1DPathEffectC1ERK6SkPathffNS_5StyleE"]
    pub fn SkPath1DPathEffect_SkPath1DPathEffect(
        this: *mut SkPath1DPathEffect,
        path: *const SkPath,
        advance: SkScalar,
        phase: SkScalar,
        arg1: SkPath1DPathEffect_Style,
    );
}
impl SkPath1DPathEffect {
    #[inline]
    pub unsafe fn Make(
        path: *const SkPath,
        advance: SkScalar,
        phase: SkScalar,
        arg1: SkPath1DPathEffect_Style,
    ) -> sk_sp<SkPathEffect> {
        SkPath1DPathEffect_Make(path, advance, phase, arg1)
    }
    #[inline]
    pub unsafe fn new(
        path: *const SkPath,
        advance: SkScalar,
        phase: SkScalar,
        arg1: SkPath1DPathEffect_Style,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkPath1DPathEffect_SkPath1DPathEffect(&mut __bindgen_tmp, path, advance, phase, arg1);
        __bindgen_tmp
    }
}
extern "C" {
    #[link_name = "\u{1}_ZNK18SkPath1DPathEffect7flattenER13SkWriteBuffer"]
    pub fn SkPath1DPathEffect_flatten(this: *mut ::std::os::raw::c_void, arg1: *mut SkWriteBuffer);
}
extern "C" {
    #[link_name = "\u{1}_ZNK18SkPath1DPathEffect12onFilterPathEP6SkPathRKS0_P11SkStrokeRecPK6SkRect"]
    pub fn SkPath1DPathEffect_onFilterPath(
        this: *mut ::std::os::raw::c_void,
        arg1: *mut SkPath,
        arg2: *const SkPath,
        arg3: *mut SkStrokeRec,
        arg4: *const SkRect,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK18SkPath1DPathEffect5beginEf"]
    pub fn SkPath1DPathEffect_begin(
        this: *mut ::std::os::raw::c_void,
        contourLength: SkScalar,
    ) -> SkScalar;
}
extern "C" {
    #[link_name = "\u{1}_ZNK18SkPath1DPathEffect4nextEP6SkPathfR13SkPathMeasure"]
    pub fn SkPath1DPathEffect_next(
        this: *mut ::std::os::raw::c_void,
        arg1: *mut SkPath,
        arg2: SkScalar,
        arg3: *mut SkPathMeasure,
    ) -> SkScalar;
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub struct Sk2DPathEffect {
    pub _bindgen_opaque_blob: [u64; 12usize],
}
pub type Sk2DPathEffect_INHERITED = SkPathEffect;
#[test]
fn bindgen_test_layout_Sk2DPathEffect() {
    assert_eq!(
        ::core::mem::size_of::<Sk2DPathEffect>(),
        96usize,
        concat!("Size of: ", stringify!(Sk2DPathEffect))
    );
    assert_eq!(
        ::core::mem::align_of::<Sk2DPathEffect>(),
        8usize,
        concat!("Alignment of ", stringify!(Sk2DPathEffect))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN14Sk2DPathEffectC2ERK8SkMatrix"]
    pub fn Sk2DPathEffect_Sk2DPathEffect(this: *mut Sk2DPathEffect, mat: *const SkMatrix);
}
impl Sk2DPathEffect {
    #[inline]
    pub unsafe fn new(mat: *const SkMatrix) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        Sk2DPathEffect_Sk2DPathEffect(&mut __bindgen_tmp, mat);
        __bindgen_tmp
    }
}
extern "C" {
    #[link_name = "\u{1}_ZNK14Sk2DPathEffect5beginERK7SkIRectP6SkPath"]
    pub fn Sk2DPathEffect_begin(
        this: *mut ::std::os::raw::c_void,
        uvBounds: *const SkIRect,
        dst: *mut SkPath,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK14Sk2DPathEffect4nextERK7SkPointiiP6SkPath"]
    pub fn Sk2DPathEffect_next(
        this: *mut ::std::os::raw::c_void,
        loc: *const SkPoint,
        u: ::std::os::raw::c_int,
        v: ::std::os::raw::c_int,
        dst: *mut SkPath,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK14Sk2DPathEffect3endEP6SkPath"]
    pub fn Sk2DPathEffect_end(this: *mut ::std::os::raw::c_void, dst: *mut SkPath);
}
extern "C" {
    #[link_name = "\u{1}_ZNK14Sk2DPathEffect8nextSpanEiiiP6SkPath"]
    pub fn Sk2DPathEffect_nextSpan(
        this: *mut ::std::os::raw::c_void,
        u: ::std::os::raw::c_int,
        v: ::std::os::raw::c_int,
        ucount: ::std::os::raw::c_int,
        dst: *mut SkPath,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK14Sk2DPathEffect7flattenER13SkWriteBuffer"]
    pub fn Sk2DPathEffect_flatten(this: *mut ::std::os::raw::c_void, arg1: *mut SkWriteBuffer);
}
extern "C" {
    #[link_name = "\u{1}_ZNK14Sk2DPathEffect12onFilterPathEP6SkPathRKS0_P11SkStrokeRecPK6SkRect"]
    pub fn Sk2DPathEffect_onFilterPath(
        this: *mut ::std::os::raw::c_void,
        arg1: *mut SkPath,
        arg2: *const SkPath,
        arg3: *mut SkStrokeRec,
        arg4: *const SkRect,
    ) -> bool;
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub struct SkLine2DPathEffect {
    pub _bindgen_opaque_blob: [u64; 13usize],
}
pub type SkLine2DPathEffect_INHERITED = Sk2DPathEffect;
#[test]
fn bindgen_test_layout_SkLine2DPathEffect() {
    assert_eq!(
        ::core::mem::size_of::<SkLine2DPathEffect>(),
        104usize,
        concat!("Size of: ", stringify!(SkLine2DPathEffect))
    );
    assert_eq!(
        ::core::mem::align_of::<SkLine2DPathEffect>(),
        8usize,
        concat!("Alignment of ", stringify!(SkLine2DPathEffect))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK18SkLine2DPathEffect7flattenER13SkWriteBuffer"]
    pub fn SkLine2DPathEffect_flatten(this: *mut ::std::os::raw::c_void, arg1: *mut SkWriteBuffer);
}
extern "C" {
    #[link_name = "\u{1}_ZNK18SkLine2DPathEffect12onFilterPathEP6SkPathRKS0_P11SkStrokeRecPK6SkRect"]
    pub fn SkLine2DPathEffect_onFilterPath(
        this: *mut ::std::os::raw::c_void,
        dst: *mut SkPath,
        src: *const SkPath,
        arg1: *mut SkStrokeRec,
        arg2: *const SkRect,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK18SkLine2DPathEffect8nextSpanEiiiP6SkPath"]
    pub fn SkLine2DPathEffect_nextSpan(
        this: *mut ::std::os::raw::c_void,
        u: ::std::os::raw::c_int,
        v: ::std::os::raw::c_int,
        ucount: ::std::os::raw::c_int,
        arg1: *mut SkPath,
    );
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub struct SkPath2DPathEffect {
    pub _bindgen_opaque_blob: [u64; 14usize],
}
pub type SkPath2DPathEffect_INHERITED = Sk2DPathEffect;
#[test]
fn bindgen_test_layout_SkPath2DPathEffect() {
    assert_eq!(
        ::core::mem::size_of::<SkPath2DPathEffect>(),
        112usize,
        concat!("Size of: ", stringify!(SkPath2DPathEffect))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPath2DPathEffect>(),
        8usize,
        concat!("Alignment of ", stringify!(SkPath2DPathEffect))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN18SkPath2DPathEffectC1ERK8SkMatrixRK6SkPath"]
    pub fn SkPath2DPathEffect_SkPath2DPathEffect(
        this: *mut SkPath2DPathEffect,
        arg1: *const SkMatrix,
        arg2: *const SkPath,
    );
}
impl SkPath2DPathEffect {
    #[inline]
    pub unsafe fn new(arg1: *const SkMatrix, arg2: *const SkPath) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkPath2DPathEffect_SkPath2DPathEffect(&mut __bindgen_tmp, arg1, arg2);
        __bindgen_tmp
    }
}
extern "C" {
    #[link_name = "\u{1}_ZNK18SkPath2DPathEffect7flattenER13SkWriteBuffer"]
    pub fn SkPath2DPathEffect_flatten(this: *mut ::std::os::raw::c_void, arg1: *mut SkWriteBuffer);
}
extern "C" {
    #[link_name = "\u{1}_ZNK18SkPath2DPathEffect4nextERK7SkPointiiP6SkPath"]
    pub fn SkPath2DPathEffect_next(
        this: *mut ::std::os::raw::c_void,
        arg1: *const SkPoint,
        u: ::std::os::raw::c_int,
        v: ::std::os::raw::c_int,
        arg2: *mut SkPath,
    );
}
impl SkBlurImageFilter_TileMode {
    pub const kLast_TileMode: SkBlurImageFilter_TileMode =
        SkBlurImageFilter_TileMode::kClampToBlack_TileMode;
}
impl SkBlurImageFilter_TileMode {
    pub const kMax_TileMode: SkBlurImageFilter_TileMode =
        SkBlurImageFilter_TileMode::kClampToBlack_TileMode;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkBlurImageFilter_TileMode {
    kClamp_TileMode = 0,
    kRepeat_TileMode = 1,
    kClampToBlack_TileMode = 2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkColorMatrix {
    pub fMat: [f32; 20usize],
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkColorMatrix_Axis {
    kR_Axis = 0,
    kG_Axis = 1,
    kB_Axis = 2,
}
#[test]
fn bindgen_test_layout_SkColorMatrix() {
    assert_eq!(
        ::core::mem::size_of::<SkColorMatrix>(),
        80usize,
        concat!("Size of: ", stringify!(SkColorMatrix))
    );
    assert_eq!(
        ::core::mem::align_of::<SkColorMatrix>(),
        4usize,
        concat!("Alignment of ", stringify!(SkColorMatrix))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkColorMatrix>())).fMat as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkColorMatrix),
            "::",
            stringify!(fMat)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkColorMatrix11setIdentityEv"]
    pub fn SkColorMatrix_setIdentity(this: *mut SkColorMatrix);
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkColorMatrix8setScaleEffff"]
    pub fn SkColorMatrix_setScale(
        this: *mut SkColorMatrix,
        rScale: f32,
        gScale: f32,
        bScale: f32,
        aScale: f32,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkColorMatrix9setRotateENS_4AxisEf"]
    pub fn SkColorMatrix_setRotate(
        this: *mut SkColorMatrix,
        arg1: SkColorMatrix_Axis,
        degrees: f32,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkColorMatrix9setSinCosENS_4AxisEff"]
    pub fn SkColorMatrix_setSinCos(
        this: *mut SkColorMatrix,
        arg1: SkColorMatrix_Axis,
        sine: f32,
        cosine: f32,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkColorMatrix9preRotateENS_4AxisEf"]
    pub fn SkColorMatrix_preRotate(
        this: *mut SkColorMatrix,
        arg1: SkColorMatrix_Axis,
        degrees: f32,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkColorMatrix10postRotateENS_4AxisEf"]
    pub fn SkColorMatrix_postRotate(
        this: *mut SkColorMatrix,
        arg1: SkColorMatrix_Axis,
        degrees: f32,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkColorMatrix13postTranslateEffff"]
    pub fn SkColorMatrix_postTranslate(
        this: *mut SkColorMatrix,
        dr: f32,
        dg: f32,
        db: f32,
        da: f32,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkColorMatrix9setConcatERKS_S1_"]
    pub fn SkColorMatrix_setConcat(
        this: *mut SkColorMatrix,
        a: *const SkColorMatrix,
        b: *const SkColorMatrix,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkColorMatrix13setSaturationEf"]
    pub fn SkColorMatrix_setSaturation(this: *mut SkColorMatrix, sat: f32);
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkColorMatrix10setRGB2YUVEv"]
    pub fn SkColorMatrix_setRGB2YUV(this: *mut SkColorMatrix);
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkColorMatrix10setYUV2RGBEv"]
    pub fn SkColorMatrix_setYUV2RGB(this: *mut SkColorMatrix);
}
impl SkColorMatrix {
    #[inline]
    pub unsafe fn setIdentity(&mut self) {
        SkColorMatrix_setIdentity(self)
    }
    #[inline]
    pub unsafe fn setScale(&mut self, rScale: f32, gScale: f32, bScale: f32, aScale: f32) {
        SkColorMatrix_setScale(self, rScale, gScale, bScale, aScale)
    }
    #[inline]
    pub unsafe fn setRotate(&mut self, arg1: SkColorMatrix_Axis, degrees: f32) {
        SkColorMatrix_setRotate(self, arg1, degrees)
    }
    #[inline]
    pub unsafe fn setSinCos(&mut self, arg1: SkColorMatrix_Axis, sine: f32, cosine: f32) {
        SkColorMatrix_setSinCos(self, arg1, sine, cosine)
    }
    #[inline]
    pub unsafe fn preRotate(&mut self, arg1: SkColorMatrix_Axis, degrees: f32) {
        SkColorMatrix_preRotate(self, arg1, degrees)
    }
    #[inline]
    pub unsafe fn postRotate(&mut self, arg1: SkColorMatrix_Axis, degrees: f32) {
        SkColorMatrix_postRotate(self, arg1, degrees)
    }
    #[inline]
    pub unsafe fn postTranslate(&mut self, dr: f32, dg: f32, db: f32, da: f32) {
        SkColorMatrix_postTranslate(self, dr, dg, db, da)
    }
    #[inline]
    pub unsafe fn setConcat(&mut self, a: *const SkColorMatrix, b: *const SkColorMatrix) {
        SkColorMatrix_setConcat(self, a, b)
    }
    #[inline]
    pub unsafe fn setSaturation(&mut self, sat: f32) {
        SkColorMatrix_setSaturation(self, sat)
    }
    #[inline]
    pub unsafe fn setRGB2YUV(&mut self) {
        SkColorMatrix_setRGB2YUV(self)
    }
    #[inline]
    pub unsafe fn setYUV2RGB(&mut self) {
        SkColorMatrix_setYUV2RGB(self)
    }
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub struct SkCornerPathEffect {
    pub _bindgen_opaque_blob: [u64; 2usize],
}
pub type SkCornerPathEffect_INHERITED = SkPathEffect;
#[test]
fn bindgen_test_layout_SkCornerPathEffect() {
    assert_eq!(
        ::core::mem::size_of::<SkCornerPathEffect>(),
        16usize,
        concat!("Size of: ", stringify!(SkCornerPathEffect))
    );
    assert_eq!(
        ::core::mem::align_of::<SkCornerPathEffect>(),
        8usize,
        concat!("Alignment of ", stringify!(SkCornerPathEffect))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN18SkCornerPathEffectC1Ef"]
    pub fn SkCornerPathEffect_SkCornerPathEffect(this: *mut SkCornerPathEffect, radius: SkScalar);
}
impl SkCornerPathEffect {
    #[inline]
    pub unsafe fn new(radius: SkScalar) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkCornerPathEffect_SkCornerPathEffect(&mut __bindgen_tmp, radius);
        __bindgen_tmp
    }
}
extern "C" {
    #[link_name = "\u{1}_ZN18SkCornerPathEffectD1Ev"]
    pub fn SkCornerPathEffect_SkCornerPathEffect_destructor(this: *mut SkCornerPathEffect);
}
extern "C" {
    #[link_name = "\u{1}_ZNK18SkCornerPathEffect7flattenER13SkWriteBuffer"]
    pub fn SkCornerPathEffect_flatten(this: *mut ::std::os::raw::c_void, arg1: *mut SkWriteBuffer);
}
extern "C" {
    #[link_name = "\u{1}_ZNK18SkCornerPathEffect12onFilterPathEP6SkPathRKS0_P11SkStrokeRecPK6SkRect"]
    pub fn SkCornerPathEffect_onFilterPath(
        this: *mut ::std::os::raw::c_void,
        dst: *mut SkPath,
        src: *const SkPath,
        arg1: *mut SkStrokeRec,
        arg2: *const SkRect,
    ) -> bool;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkDashPathEffect {
    pub _address: u8,
}
#[test]
fn bindgen_test_layout_SkDashPathEffect() {
    assert_eq!(
        ::core::mem::size_of::<SkDashPathEffect>(),
        1usize,
        concat!("Size of: ", stringify!(SkDashPathEffect))
    );
    assert_eq!(
        ::core::mem::align_of::<SkDashPathEffect>(),
        1usize,
        concat!("Alignment of ", stringify!(SkDashPathEffect))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN16SkDashPathEffect4MakeEPKfif"]
    pub fn SkDashPathEffect_Make(
        intervals: *const SkScalar,
        count: ::std::os::raw::c_int,
        phase: SkScalar,
    ) -> sk_sp<SkPathEffect>;
}
impl SkDashPathEffect {
    #[inline]
    pub unsafe fn Make(
        intervals: *const SkScalar,
        count: ::std::os::raw::c_int,
        phase: SkScalar,
    ) -> sk_sp<SkPathEffect> {
        SkDashPathEffect_Make(intervals, count, phase)
    }
}
#[repr(C)]
#[repr(align(8))]
#[derive(Copy, Clone)]
pub struct SkDiscretePathEffect {
    pub _bindgen_opaque_blob: [u64; 3usize],
}
pub type SkDiscretePathEffect_INHERITED = SkPathEffect;
#[test]
fn bindgen_test_layout_SkDiscretePathEffect() {
    assert_eq!(
        ::core::mem::size_of::<SkDiscretePathEffect>(),
        24usize,
        concat!("Size of: ", stringify!(SkDiscretePathEffect))
    );
    assert_eq!(
        ::core::mem::align_of::<SkDiscretePathEffect>(),
        8usize,
        concat!("Alignment of ", stringify!(SkDiscretePathEffect))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN20SkDiscretePathEffect4MakeEffj"]
    pub fn SkDiscretePathEffect_Make(
        segLength: SkScalar,
        dev: SkScalar,
        seedAssist: u32,
    ) -> sk_sp<SkPathEffect>;
}
extern "C" {
    #[link_name = "\u{1}_ZN20SkDiscretePathEffectC1Effj"]
    pub fn SkDiscretePathEffect_SkDiscretePathEffect(
        this: *mut SkDiscretePathEffect,
        segLength: SkScalar,
        deviation: SkScalar,
        seedAssist: u32,
    );
}
impl SkDiscretePathEffect {
    #[inline]
    pub unsafe fn Make(segLength: SkScalar, dev: SkScalar, seedAssist: u32) -> sk_sp<SkPathEffect> {
        SkDiscretePathEffect_Make(segLength, dev, seedAssist)
    }
    #[inline]
    pub unsafe fn new(segLength: SkScalar, deviation: SkScalar, seedAssist: u32) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkDiscretePathEffect_SkDiscretePathEffect(
            &mut __bindgen_tmp,
            segLength,
            deviation,
            seedAssist,
        );
        __bindgen_tmp
    }
}
extern "C" {
    #[link_name = "\u{1}_ZNK20SkDiscretePathEffect7flattenER13SkWriteBuffer"]
    pub fn SkDiscretePathEffect_flatten(
        this: *mut ::std::os::raw::c_void,
        arg1: *mut SkWriteBuffer,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK20SkDiscretePathEffect12onFilterPathEP6SkPathRKS0_P11SkStrokeRecPK6SkRect"]
    pub fn SkDiscretePathEffect_onFilterPath(
        this: *mut ::std::os::raw::c_void,
        dst: *mut SkPath,
        src: *const SkPath,
        arg1: *mut SkStrokeRec,
        arg2: *const SkRect,
    ) -> bool;
}
impl SkDisplacementMapEffect_ChannelSelectorType {
    pub const kLast_ChannelSelectorType: SkDisplacementMapEffect_ChannelSelectorType =
        SkDisplacementMapEffect_ChannelSelectorType::kA_ChannelSelectorType;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkDisplacementMapEffect_ChannelSelectorType {
    kUnknown_ChannelSelectorType = 0,
    kR_ChannelSelectorType = 1,
    kG_ChannelSelectorType = 2,
    kB_ChannelSelectorType = 3,
    kA_ChannelSelectorType = 4,
}
impl SkDropShadowImageFilter_ShadowMode {
    pub const kLast_ShadowMode: SkDropShadowImageFilter_ShadowMode =
        SkDropShadowImageFilter_ShadowMode::kDrawShadowOnly_ShadowMode;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkDropShadowImageFilter_ShadowMode {
    kDrawShadowAndForeground_ShadowMode = 0,
    kDrawShadowOnly_ShadowMode = 1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkGradientShader {
    pub _address: u8,
}
pub const SkGradientShader_Flags_kInterpolateColorsInPremul_Flag: SkGradientShader_Flags = 1;
pub type SkGradientShader_Flags = u32;
#[test]
fn bindgen_test_layout_SkGradientShader() {
    assert_eq!(
        ::core::mem::size_of::<SkGradientShader>(),
        1usize,
        concat!("Size of: ", stringify!(SkGradientShader))
    );
    assert_eq!(
        ::core::mem::align_of::<SkGradientShader>(),
        1usize,
        concat!("Alignment of ", stringify!(SkGradientShader))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN16SkGradientShader10MakeLinearEPK7SkPointPKjPKfi10SkTileModejPK8SkMatrix"]
    pub fn SkGradientShader_MakeLinear(
        pts: *const SkPoint,
        colors: *const SkColor,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader>;
}
extern "C" {
    #[link_name = "\u{1}_ZN16SkGradientShader10MakeLinearEPK7SkPointPK8SkRGBA4fIL11SkAlphaType3EE5sk_spI12SkColorSpaceEPKfi10SkTileModejPK8SkMatrix"]
    pub fn SkGradientShader_MakeLinear1(
        pts: *const SkPoint,
        colors: *const SkColor4f,
        colorSpace: sk_sp<SkColorSpace>,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader>;
}
extern "C" {
    #[link_name = "\u{1}_ZN16SkGradientShader10MakeRadialERK7SkPointfPKjPKfi10SkTileModejPK8SkMatrix"]
    pub fn SkGradientShader_MakeRadial(
        center: *const SkPoint,
        radius: SkScalar,
        colors: *const SkColor,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader>;
}
extern "C" {
    #[link_name = "\u{1}_ZN16SkGradientShader10MakeRadialERK7SkPointfPK8SkRGBA4fIL11SkAlphaType3EE5sk_spI12SkColorSpaceEPKfi10SkTileModejPK8SkMatrix"]
    pub fn SkGradientShader_MakeRadial1(
        center: *const SkPoint,
        radius: SkScalar,
        colors: *const SkColor4f,
        colorSpace: sk_sp<SkColorSpace>,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader>;
}
extern "C" {
    #[link_name = "\u{1}_ZN16SkGradientShader19MakeTwoPointConicalERK7SkPointfS2_fPKjPKfi10SkTileModejPK8SkMatrix"]
    pub fn SkGradientShader_MakeTwoPointConical(
        start: *const SkPoint,
        startRadius: SkScalar,
        end: *const SkPoint,
        endRadius: SkScalar,
        colors: *const SkColor,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader>;
}
extern "C" {
    #[link_name = "\u{1}_ZN16SkGradientShader19MakeTwoPointConicalERK7SkPointfS2_fPK8SkRGBA4fIL11SkAlphaType3EE5sk_spI12SkColorSpaceEPKfi10SkTileModejPK8SkMatrix"]
    pub fn SkGradientShader_MakeTwoPointConical1(
        start: *const SkPoint,
        startRadius: SkScalar,
        end: *const SkPoint,
        endRadius: SkScalar,
        colors: *const SkColor4f,
        colorSpace: sk_sp<SkColorSpace>,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader>;
}
extern "C" {
    #[link_name = "\u{1}_ZN16SkGradientShader9MakeSweepEffPKjPKfi10SkTileModeffjPK8SkMatrix"]
    pub fn SkGradientShader_MakeSweep(
        cx: SkScalar,
        cy: SkScalar,
        colors: *const SkColor,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        startAngle: SkScalar,
        endAngle: SkScalar,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader>;
}
extern "C" {
    #[link_name = "\u{1}_ZN16SkGradientShader9MakeSweepEffPK8SkRGBA4fIL11SkAlphaType3EE5sk_spI12SkColorSpaceEPKfi10SkTileModeffjPK8SkMatrix"]
    pub fn SkGradientShader_MakeSweep1(
        cx: SkScalar,
        cy: SkScalar,
        colors: *const SkColor4f,
        colorSpace: sk_sp<SkColorSpace>,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        startAngle: SkScalar,
        endAngle: SkScalar,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader>;
}
extern "C" {
    #[link_name = "\u{1}_ZN16SkGradientShader20RegisterFlattenablesEv"]
    pub fn SkGradientShader_RegisterFlattenables();
}
impl SkGradientShader {
    #[inline]
    pub unsafe fn MakeLinear(
        pts: *const SkPoint,
        colors: *const SkColor,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader> {
        SkGradientShader_MakeLinear(pts, colors, pos, count, mode, flags, localMatrix)
    }
    #[inline]
    pub unsafe fn MakeLinear1(
        pts: *const SkPoint,
        colors: *const SkColor4f,
        colorSpace: sk_sp<SkColorSpace>,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader> {
        SkGradientShader_MakeLinear1(
            pts,
            colors,
            colorSpace,
            pos,
            count,
            mode,
            flags,
            localMatrix,
        )
    }
    #[inline]
    pub unsafe fn MakeRadial(
        center: *const SkPoint,
        radius: SkScalar,
        colors: *const SkColor,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader> {
        SkGradientShader_MakeRadial(center, radius, colors, pos, count, mode, flags, localMatrix)
    }
    #[inline]
    pub unsafe fn MakeRadial1(
        center: *const SkPoint,
        radius: SkScalar,
        colors: *const SkColor4f,
        colorSpace: sk_sp<SkColorSpace>,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader> {
        SkGradientShader_MakeRadial1(
            center,
            radius,
            colors,
            colorSpace,
            pos,
            count,
            mode,
            flags,
            localMatrix,
        )
    }
    #[inline]
    pub unsafe fn MakeTwoPointConical(
        start: *const SkPoint,
        startRadius: SkScalar,
        end: *const SkPoint,
        endRadius: SkScalar,
        colors: *const SkColor,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader> {
        SkGradientShader_MakeTwoPointConical(
            start,
            startRadius,
            end,
            endRadius,
            colors,
            pos,
            count,
            mode,
            flags,
            localMatrix,
        )
    }
    #[inline]
    pub unsafe fn MakeTwoPointConical1(
        start: *const SkPoint,
        startRadius: SkScalar,
        end: *const SkPoint,
        endRadius: SkScalar,
        colors: *const SkColor4f,
        colorSpace: sk_sp<SkColorSpace>,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader> {
        SkGradientShader_MakeTwoPointConical1(
            start,
            startRadius,
            end,
            endRadius,
            colors,
            colorSpace,
            pos,
            count,
            mode,
            flags,
            localMatrix,
        )
    }
    #[inline]
    pub unsafe fn MakeSweep(
        cx: SkScalar,
        cy: SkScalar,
        colors: *const SkColor,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        startAngle: SkScalar,
        endAngle: SkScalar,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader> {
        SkGradientShader_MakeSweep(
            cx,
            cy,
            colors,
            pos,
            count,
            mode,
            startAngle,
            endAngle,
            flags,
            localMatrix,
        )
    }
    #[inline]
    pub unsafe fn MakeSweep1(
        cx: SkScalar,
        cy: SkScalar,
        colors: *const SkColor4f,
        colorSpace: sk_sp<SkColorSpace>,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        startAngle: SkScalar,
        endAngle: SkScalar,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> sk_sp<SkShader> {
        SkGradientShader_MakeSweep1(
            cx,
            cy,
            colors,
            colorSpace,
            pos,
            count,
            mode,
            startAngle,
            endAngle,
            flags,
            localMatrix,
        )
    }
    #[inline]
    pub unsafe fn RegisterFlattenables() {
        SkGradientShader_RegisterFlattenables()
    }
}
pub const SkLayerDrawLooper_Bits_kStyle_Bit: SkLayerDrawLooper_Bits = 1;
pub const SkLayerDrawLooper_Bits_kPathEffect_Bit: SkLayerDrawLooper_Bits = 4;
pub const SkLayerDrawLooper_Bits_kMaskFilter_Bit: SkLayerDrawLooper_Bits = 8;
pub const SkLayerDrawLooper_Bits_kShader_Bit: SkLayerDrawLooper_Bits = 16;
pub const SkLayerDrawLooper_Bits_kColorFilter_Bit: SkLayerDrawLooper_Bits = 32;
pub const SkLayerDrawLooper_Bits_kXfermode_Bit: SkLayerDrawLooper_Bits = 64;
pub const SkLayerDrawLooper_Bits_kEntirePaint_Bits: SkLayerDrawLooper_Bits = -1;
pub type SkLayerDrawLooper_Bits = i32;
pub type SkLayerDrawLooper_BitFlags = i32;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkLayerDrawLooper_LayerInfo {
    pub fPaintBits: SkLayerDrawLooper_BitFlags,
    pub fColorMode: SkBlendMode,
    pub fOffset: SkVector,
    pub fPostTranslate: bool,
}
#[test]
fn bindgen_test_layout_SkLayerDrawLooper_LayerInfo() {
    assert_eq!(
        ::core::mem::size_of::<SkLayerDrawLooper_LayerInfo>(),
        20usize,
        concat!("Size of: ", stringify!(SkLayerDrawLooper_LayerInfo))
    );
    assert_eq!(
        ::core::mem::align_of::<SkLayerDrawLooper_LayerInfo>(),
        4usize,
        concat!("Alignment of ", stringify!(SkLayerDrawLooper_LayerInfo))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkLayerDrawLooper_LayerInfo>())).fPaintBits as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkLayerDrawLooper_LayerInfo),
            "::",
            stringify!(fPaintBits)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkLayerDrawLooper_LayerInfo>())).fColorMode as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkLayerDrawLooper_LayerInfo),
            "::",
            stringify!(fColorMode)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkLayerDrawLooper_LayerInfo>())).fOffset as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkLayerDrawLooper_LayerInfo),
            "::",
            stringify!(fOffset)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkLayerDrawLooper_LayerInfo>())).fPostTranslate as *const _
                as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkLayerDrawLooper_LayerInfo),
            "::",
            stringify!(fPostTranslate)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkLayerDrawLooper9LayerInfoC1Ev"]
    pub fn SkLayerDrawLooper_LayerInfo_LayerInfo(this: *mut SkLayerDrawLooper_LayerInfo);
}
impl SkLayerDrawLooper_LayerInfo {
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkLayerDrawLooper_LayerInfo_LayerInfo(&mut __bindgen_tmp);
        __bindgen_tmp
    }
}
#[repr(C)]
pub struct SkLayerDrawLooper_Rec {
    pub fNext: *mut SkLayerDrawLooper_Rec,
    pub fPaint: SkPaint,
    pub fInfo: SkLayerDrawLooper_LayerInfo,
}
#[test]
fn bindgen_test_layout_SkLayerDrawLooper_Rec() {
    assert_eq!(
        ::core::mem::size_of::<SkLayerDrawLooper_Rec>(),
        112usize,
        concat!("Size of: ", stringify!(SkLayerDrawLooper_Rec))
    );
    assert_eq!(
        ::core::mem::align_of::<SkLayerDrawLooper_Rec>(),
        8usize,
        concat!("Alignment of ", stringify!(SkLayerDrawLooper_Rec))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkLayerDrawLooper_Rec>())).fNext as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkLayerDrawLooper_Rec),
            "::",
            stringify!(fNext)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkLayerDrawLooper_Rec>())).fPaint as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkLayerDrawLooper_Rec),
            "::",
            stringify!(fPaint)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkLayerDrawLooper_Rec>())).fInfo as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(SkLayerDrawLooper_Rec),
            "::",
            stringify!(fInfo)
        )
    );
}
#[repr(C)]
pub struct SkLayerDrawLooper_Builder {
    pub fRecs: *mut SkLayerDrawLooper_Rec,
    pub fTopRec: *mut SkLayerDrawLooper_Rec,
    pub fCount: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_SkLayerDrawLooper_Builder() {
    assert_eq!(
        ::core::mem::size_of::<SkLayerDrawLooper_Builder>(),
        24usize,
        concat!("Size of: ", stringify!(SkLayerDrawLooper_Builder))
    );
    assert_eq!(
        ::core::mem::align_of::<SkLayerDrawLooper_Builder>(),
        8usize,
        concat!("Alignment of ", stringify!(SkLayerDrawLooper_Builder))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkLayerDrawLooper_Builder>())).fRecs as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkLayerDrawLooper_Builder),
            "::",
            stringify!(fRecs)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkLayerDrawLooper_Builder>())).fTopRec as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkLayerDrawLooper_Builder),
            "::",
            stringify!(fTopRec)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkLayerDrawLooper_Builder>())).fCount as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkLayerDrawLooper_Builder),
            "::",
            stringify!(fCount)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkLayerDrawLooper7Builder8addLayerERKNS_9LayerInfoE"]
    pub fn SkLayerDrawLooper_Builder_addLayer(
        this: *mut SkLayerDrawLooper_Builder,
        arg1: *const SkLayerDrawLooper_LayerInfo,
    ) -> *mut SkPaint;
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkLayerDrawLooper7Builder8addLayerEff"]
    pub fn SkLayerDrawLooper_Builder_addLayer1(
        this: *mut SkLayerDrawLooper_Builder,
        dx: SkScalar,
        dy: SkScalar,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkLayerDrawLooper7Builder13addLayerOnTopERKNS_9LayerInfoE"]
    pub fn SkLayerDrawLooper_Builder_addLayerOnTop(
        this: *mut SkLayerDrawLooper_Builder,
        arg1: *const SkLayerDrawLooper_LayerInfo,
    ) -> *mut SkPaint;
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkLayerDrawLooper7Builder6detachEv"]
    pub fn SkLayerDrawLooper_Builder_detach(
        this: *mut SkLayerDrawLooper_Builder,
    ) -> sk_sp<SkDrawLooper>;
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkLayerDrawLooper7BuilderC1Ev"]
    pub fn SkLayerDrawLooper_Builder_Builder(this: *mut SkLayerDrawLooper_Builder);
}
extern "C" {
    #[link_name = "\u{1}_ZN17SkLayerDrawLooper7BuilderD1Ev"]
    pub fn SkLayerDrawLooper_Builder_Builder_destructor(this: *mut SkLayerDrawLooper_Builder);
}
impl SkLayerDrawLooper_Builder {
    #[inline]
    pub unsafe fn addLayer(&mut self, arg1: *const SkLayerDrawLooper_LayerInfo) -> *mut SkPaint {
        SkLayerDrawLooper_Builder_addLayer(self, arg1)
    }
    #[inline]
    pub unsafe fn addLayer1(&mut self, dx: SkScalar, dy: SkScalar) {
        SkLayerDrawLooper_Builder_addLayer1(self, dx, dy)
    }
    #[inline]
    pub unsafe fn addLayerOnTop(
        &mut self,
        arg1: *const SkLayerDrawLooper_LayerInfo,
    ) -> *mut SkPaint {
        SkLayerDrawLooper_Builder_addLayerOnTop(self, arg1)
    }
    #[inline]
    pub unsafe fn detach(&mut self) -> sk_sp<SkDrawLooper> {
        SkLayerDrawLooper_Builder_detach(self)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkLayerDrawLooper_Builder_Builder(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        SkLayerDrawLooper_Builder_Builder_destructor(self)
    }
}
impl SkMatrixConvolutionImageFilter_TileMode {
    pub const kLast_TileMode: SkMatrixConvolutionImageFilter_TileMode =
        SkMatrixConvolutionImageFilter_TileMode::kClampToBlack_TileMode;
}
impl SkMatrixConvolutionImageFilter_TileMode {
    pub const kMax_TileMode: SkMatrixConvolutionImageFilter_TileMode =
        SkMatrixConvolutionImageFilter_TileMode::kClampToBlack_TileMode;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkMatrixConvolutionImageFilter_TileMode {
    kClamp_TileMode = 0,
    kRepeat_TileMode = 1,
    kClampToBlack_TileMode = 2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkPerlinNoiseShader {
    pub _address: u8,
}
#[test]
fn bindgen_test_layout_SkPerlinNoiseShader() {
    assert_eq!(
        ::core::mem::size_of::<SkPerlinNoiseShader>(),
        1usize,
        concat!("Size of: ", stringify!(SkPerlinNoiseShader))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPerlinNoiseShader>(),
        1usize,
        concat!("Alignment of ", stringify!(SkPerlinNoiseShader))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN19SkPerlinNoiseShader16MakeFractalNoiseEffifPK7SkISize"]
    pub fn SkPerlinNoiseShader_MakeFractalNoise(
        baseFrequencyX: SkScalar,
        baseFrequencyY: SkScalar,
        numOctaves: ::std::os::raw::c_int,
        seed: SkScalar,
        tileSize: *const SkISize,
    ) -> sk_sp<SkShader>;
}
extern "C" {
    #[link_name = "\u{1}_ZN19SkPerlinNoiseShader14MakeTurbulenceEffifPK7SkISize"]
    pub fn SkPerlinNoiseShader_MakeTurbulence(
        baseFrequencyX: SkScalar,
        baseFrequencyY: SkScalar,
        numOctaves: ::std::os::raw::c_int,
        seed: SkScalar,
        tileSize: *const SkISize,
    ) -> sk_sp<SkShader>;
}
extern "C" {
    #[link_name = "\u{1}_ZN19SkPerlinNoiseShader17MakeImprovedNoiseEffif"]
    pub fn SkPerlinNoiseShader_MakeImprovedNoise(
        baseFrequencyX: SkScalar,
        baseFrequencyY: SkScalar,
        numOctaves: ::std::os::raw::c_int,
        z: SkScalar,
    ) -> sk_sp<SkShader>;
}
extern "C" {
    #[link_name = "\u{1}_ZN19SkPerlinNoiseShader20RegisterFlattenablesEv"]
    pub fn SkPerlinNoiseShader_RegisterFlattenables();
}
impl SkPerlinNoiseShader {
    #[inline]
    pub unsafe fn MakeFractalNoise(
        baseFrequencyX: SkScalar,
        baseFrequencyY: SkScalar,
        numOctaves: ::std::os::raw::c_int,
        seed: SkScalar,
        tileSize: *const SkISize,
    ) -> sk_sp<SkShader> {
        SkPerlinNoiseShader_MakeFractalNoise(
            baseFrequencyX,
            baseFrequencyY,
            numOctaves,
            seed,
            tileSize,
        )
    }
    #[inline]
    pub unsafe fn MakeTurbulence(
        baseFrequencyX: SkScalar,
        baseFrequencyY: SkScalar,
        numOctaves: ::std::os::raw::c_int,
        seed: SkScalar,
        tileSize: *const SkISize,
    ) -> sk_sp<SkShader> {
        SkPerlinNoiseShader_MakeTurbulence(
            baseFrequencyX,
            baseFrequencyY,
            numOctaves,
            seed,
            tileSize,
        )
    }
    #[inline]
    pub unsafe fn MakeImprovedNoise(
        baseFrequencyX: SkScalar,
        baseFrequencyY: SkScalar,
        numOctaves: ::std::os::raw::c_int,
        z: SkScalar,
    ) -> sk_sp<SkShader> {
        SkPerlinNoiseShader_MakeImprovedNoise(baseFrequencyX, baseFrequencyY, numOctaves, z)
    }
    #[inline]
    pub unsafe fn RegisterFlattenables() {
        SkPerlinNoiseShader_RegisterFlattenables()
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkTableColorFilter {
    pub _address: u8,
}
#[test]
fn bindgen_test_layout_SkTableColorFilter() {
    assert_eq!(
        ::core::mem::size_of::<SkTableColorFilter>(),
        1usize,
        concat!("Size of: ", stringify!(SkTableColorFilter))
    );
    assert_eq!(
        ::core::mem::align_of::<SkTableColorFilter>(),
        1usize,
        concat!("Alignment of ", stringify!(SkTableColorFilter))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN18SkTableColorFilter4MakeEPKh"]
    pub fn SkTableColorFilter_Make(table: *const u8) -> sk_sp<SkColorFilter>;
}
extern "C" {
    #[link_name = "\u{1}_ZN18SkTableColorFilter8MakeARGBEPKhS1_S1_S1_"]
    pub fn SkTableColorFilter_MakeARGB(
        tableA: *const u8,
        tableR: *const u8,
        tableG: *const u8,
        tableB: *const u8,
    ) -> sk_sp<SkColorFilter>;
}
extern "C" {
    #[link_name = "\u{1}_ZN18SkTableColorFilter20RegisterFlattenablesEv"]
    pub fn SkTableColorFilter_RegisterFlattenables();
}
impl SkTableColorFilter {
    #[inline]
    pub unsafe fn Make(table: *const u8) -> sk_sp<SkColorFilter> {
        SkTableColorFilter_Make(table)
    }
    #[inline]
    pub unsafe fn MakeARGB(
        tableA: *const u8,
        tableR: *const u8,
        tableG: *const u8,
        tableB: *const u8,
    ) -> sk_sp<SkColorFilter> {
        SkTableColorFilter_MakeARGB(tableA, tableR, tableG, tableB)
    }
    #[inline]
    pub unsafe fn RegisterFlattenables() {
        SkTableColorFilter_RegisterFlattenables()
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GrBackendDrawableInfo {
    pub fIsValid: bool,
    pub fBackend: GrBackendApi,
    pub fVkInfo: GrVkDrawableInfo,
}
#[test]
fn bindgen_test_layout_GrBackendDrawableInfo() {
    assert_eq!(
        ::core::mem::size_of::<GrBackendDrawableInfo>(),
        56usize,
        concat!("Size of: ", stringify!(GrBackendDrawableInfo))
    );
    assert_eq!(
        ::core::mem::align_of::<GrBackendDrawableInfo>(),
        8usize,
        concat!("Alignment of ", stringify!(GrBackendDrawableInfo))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrBackendDrawableInfo>())).fIsValid as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendDrawableInfo),
            "::",
            stringify!(fIsValid)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrBackendDrawableInfo>())).fBackend as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendDrawableInfo),
            "::",
            stringify!(fBackend)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<GrBackendDrawableInfo>())).fVkInfo as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(GrBackendDrawableInfo),
            "::",
            stringify!(fVkInfo)
        )
    );
}
#[repr(C)]
#[repr(align(8))]
pub struct GrGLInterface {
    pub _bindgen_opaque_blob: [u64; 1081usize],
}
pub type GrGLInterface_INHERITED = SkRefCnt;
#[repr(C)]
#[derive(Copy, Clone)]
pub union GrGLInterface__bindgen_ty_1 {
    pub fStandard: GrGLStandard,
    pub fBindingsExported: GrGLStandard,
    _bindgen_union_align: u32,
}
#[test]
fn bindgen_test_layout_GrGLInterface__bindgen_ty_1() {
    assert_eq!(
        ::core::mem::size_of::<GrGLInterface__bindgen_ty_1>(),
        4usize,
        concat!("Size of: ", stringify!(GrGLInterface__bindgen_ty_1))
    );
    assert_eq!(
        ::core::mem::align_of::<GrGLInterface__bindgen_ty_1>(),
        4usize,
        concat!("Alignment of ", stringify!(GrGLInterface__bindgen_ty_1))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrGLInterface__bindgen_ty_1>())).fStandard as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLInterface__bindgen_ty_1),
            "::",
            stringify!(fStandard)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<GrGLInterface__bindgen_ty_1>())).fBindingsExported as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(GrGLInterface__bindgen_ty_1),
            "::",
            stringify!(fBindingsExported)
        )
    );
}
#[repr(C)]
#[repr(align(8))]
pub struct GrGLInterface_Functions {
    pub _bindgen_opaque_blob: [u64; 1075usize],
}
#[test]
fn bindgen_test_layout_GrGLInterface_Functions() {
    assert_eq!(
        ::core::mem::size_of::<GrGLInterface_Functions>(),
        8600usize,
        concat!("Size of: ", stringify!(GrGLInterface_Functions))
    );
    assert_eq!(
        ::core::mem::align_of::<GrGLInterface_Functions>(),
        8usize,
        concat!("Alignment of ", stringify!(GrGLInterface_Functions))
    );
}
#[test]
fn bindgen_test_layout_GrGLInterface() {
    assert_eq!(
        ::core::mem::size_of::<GrGLInterface>(),
        8648usize,
        concat!("Size of: ", stringify!(GrGLInterface))
    );
    assert_eq!(
        ::core::mem::align_of::<GrGLInterface>(),
        8usize,
        concat!("Alignment of ", stringify!(GrGLInterface))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK13GrGLInterface8validateEv"]
    pub fn GrGLInterface_validate(this: *const GrGLInterface) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN13GrGLInterfaceC1Ev"]
    pub fn GrGLInterface_GrGLInterface(this: *mut GrGLInterface);
}
impl GrGLInterface {
    #[inline]
    pub unsafe fn validate(&self) -> bool {
        GrGLInterface_validate(self)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        GrGLInterface_GrGLInterface(&mut __bindgen_tmp);
        __bindgen_tmp
    }
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkPathOp {
    kDifference_SkPathOp = 0,
    kIntersect_SkPathOp = 1,
    kUnion_SkPathOp = 2,
    kXOR_SkPathOp = 3,
    kReverseDifference_SkPathOp = 4,
}
extern "C" {
    #[link_name = "\u{1}_Z2OpRK6SkPathS1_8SkPathOpPS_"]
    pub fn Op(one: *const SkPath, two: *const SkPath, op: SkPathOp, result: *mut SkPath) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_Z8SimplifyRK6SkPathPS_"]
    pub fn Simplify(path: *const SkPath, result: *mut SkPath) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_Z11TightBoundsRK6SkPathP6SkRect"]
    pub fn TightBounds(path: *const SkPath, result: *mut SkRect) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_Z9AsWindingRK6SkPathPS_"]
    pub fn AsWinding(path: *const SkPath, result: *mut SkPath) -> bool;
}
#[repr(C)]
pub struct SkOpBuilder {
    pub fPathRefs: [u64; 3usize],
    pub fOps: SkTDArray<SkPathOp>,
}
#[test]
fn bindgen_test_layout_SkOpBuilder() {
    assert_eq!(
        ::core::mem::size_of::<SkOpBuilder>(),
        40usize,
        concat!("Size of: ", stringify!(SkOpBuilder))
    );
    assert_eq!(
        ::core::mem::align_of::<SkOpBuilder>(),
        8usize,
        concat!("Alignment of ", stringify!(SkOpBuilder))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkOpBuilder>())).fPathRefs as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkOpBuilder),
            "::",
            stringify!(fPathRefs)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkOpBuilder>())).fOps as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkOpBuilder),
            "::",
            stringify!(fOps)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkOpBuilder3addERK6SkPath8SkPathOp"]
    pub fn SkOpBuilder_add(this: *mut SkOpBuilder, path: *const SkPath, _operator: SkPathOp);
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkOpBuilder7resolveEP6SkPath"]
    pub fn SkOpBuilder_resolve(this: *mut SkOpBuilder, result: *mut SkPath) -> bool;
}
impl SkOpBuilder {
    #[inline]
    pub unsafe fn add(&mut self, path: *const SkPath, _operator: SkPathOp) {
        SkOpBuilder_add(self, path, _operator)
    }
    #[inline]
    pub unsafe fn resolve(&mut self, result: *mut SkPath) -> bool {
        SkOpBuilder_resolve(self, result)
    }
}
extern "C" {
    #[link_name = "\u{1}_Z9Sk3LookAtP10SkMatrix44RK8SkPoint3S3_S3_"]
    pub fn Sk3LookAt(
        dst: *mut SkMatrix44,
        eye: *const SkPoint3,
        center: *const SkPoint3,
        up: *const SkPoint3,
    );
}
extern "C" {
    #[link_name = "\u{1}_Z14Sk3PerspectiveP10SkMatrix44fff"]
    pub fn Sk3Perspective(dst: *mut SkMatrix44, near: f32, far: f32, angle: f32) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_Z9Sk3MapPtsP7SkPointRK10SkMatrix44PK8SkPoint3i"]
    pub fn Sk3MapPts(
        dst: *mut SkPoint,
        m4: *const SkMatrix44,
        src: *const SkPoint3,
        count: ::std::os::raw::c_int,
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkNoncopyable {
    pub _address: u8,
}
#[test]
fn bindgen_test_layout_SkNoncopyable() {
    assert_eq!(
        ::core::mem::size_of::<SkNoncopyable>(),
        1usize,
        concat!("Size of: ", stringify!(SkNoncopyable))
    );
    assert_eq!(
        ::core::mem::align_of::<SkNoncopyable>(),
        1usize,
        concat!("Alignment of ", stringify!(SkNoncopyable))
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkUnit3D {
    pub fX: SkScalar,
    pub fY: SkScalar,
    pub fZ: SkScalar,
}
#[test]
fn bindgen_test_layout_SkUnit3D() {
    assert_eq!(
        ::core::mem::size_of::<SkUnit3D>(),
        12usize,
        concat!("Size of: ", stringify!(SkUnit3D))
    );
    assert_eq!(
        ::core::mem::align_of::<SkUnit3D>(),
        4usize,
        concat!("Alignment of ", stringify!(SkUnit3D))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkUnit3D>())).fX as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkUnit3D),
            "::",
            stringify!(fX)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkUnit3D>())).fY as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkUnit3D),
            "::",
            stringify!(fY)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkUnit3D>())).fZ as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkUnit3D),
            "::",
            stringify!(fZ)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkUnit3D3DotERKS_S1_"]
    pub fn SkUnit3D_Dot(arg1: *const SkUnit3D, arg2: *const SkUnit3D) -> SkScalar;
}
extern "C" {
    #[link_name = "\u{1}_ZN8SkUnit3D5CrossERKS_S1_PS_"]
    pub fn SkUnit3D_Cross(arg1: *const SkUnit3D, arg2: *const SkUnit3D, cross: *mut SkUnit3D);
}
impl SkUnit3D {
    #[inline]
    pub unsafe fn Dot(arg1: *const SkUnit3D, arg2: *const SkUnit3D) -> SkScalar {
        SkUnit3D_Dot(arg1, arg2)
    }
    #[inline]
    pub unsafe fn Cross(arg1: *const SkUnit3D, arg2: *const SkUnit3D, cross: *mut SkUnit3D) {
        SkUnit3D_Cross(arg1, arg2, cross)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkPoint3D {
    pub fX: SkScalar,
    pub fY: SkScalar,
    pub fZ: SkScalar,
}
#[test]
fn bindgen_test_layout_SkPoint3D() {
    assert_eq!(
        ::core::mem::size_of::<SkPoint3D>(),
        12usize,
        concat!("Size of: ", stringify!(SkPoint3D))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPoint3D>(),
        4usize,
        concat!("Alignment of ", stringify!(SkPoint3D))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPoint3D>())).fX as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPoint3D),
            "::",
            stringify!(fX)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPoint3D>())).fY as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPoint3D),
            "::",
            stringify!(fY)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPoint3D>())).fZ as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPoint3D),
            "::",
            stringify!(fZ)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkPoint3D9normalizeEP8SkUnit3D"]
    pub fn SkPoint3D_normalize(this: *const SkPoint3D, arg1: *mut SkUnit3D) -> SkScalar;
}
impl SkPoint3D {
    #[inline]
    pub unsafe fn normalize(&self, arg1: *mut SkUnit3D) -> SkScalar {
        SkPoint3D_normalize(self, arg1)
    }
}
pub type SkVector3D = SkPoint3D;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkMatrix3D {
    pub fMat: [[SkScalar; 4usize]; 3usize],
}
#[test]
fn bindgen_test_layout_SkMatrix3D() {
    assert_eq!(
        ::core::mem::size_of::<SkMatrix3D>(),
        48usize,
        concat!("Size of: ", stringify!(SkMatrix3D))
    );
    assert_eq!(
        ::core::mem::align_of::<SkMatrix3D>(),
        4usize,
        concat!("Alignment of ", stringify!(SkMatrix3D))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkMatrix3D>())).fMat as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkMatrix3D),
            "::",
            stringify!(fMat)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix3D5resetEv"]
    pub fn SkMatrix3D_reset(this: *mut SkMatrix3D);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix3D10setRotateXEf"]
    pub fn SkMatrix3D_setRotateX(this: *mut SkMatrix3D, deg: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix3D10setRotateYEf"]
    pub fn SkMatrix3D_setRotateY(this: *mut SkMatrix3D, deg: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix3D10setRotateZEf"]
    pub fn SkMatrix3D_setRotateZ(this: *mut SkMatrix3D, deg: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix3D12setTranslateEfff"]
    pub fn SkMatrix3D_setTranslate(this: *mut SkMatrix3D, x: SkScalar, y: SkScalar, z: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix3D10preRotateXEf"]
    pub fn SkMatrix3D_preRotateX(this: *mut SkMatrix3D, deg: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix3D10preRotateYEf"]
    pub fn SkMatrix3D_preRotateY(this: *mut SkMatrix3D, deg: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix3D10preRotateZEf"]
    pub fn SkMatrix3D_preRotateZ(this: *mut SkMatrix3D, deg: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix3D12preTranslateEfff"]
    pub fn SkMatrix3D_preTranslate(this: *mut SkMatrix3D, x: SkScalar, y: SkScalar, z: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkMatrix3D9setConcatERKS_S1_"]
    pub fn SkMatrix3D_setConcat(this: *mut SkMatrix3D, a: *const SkMatrix3D, b: *const SkMatrix3D);
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkMatrix3D8mapPointERK9SkPoint3DPS0_"]
    pub fn SkMatrix3D_mapPoint(this: *const SkMatrix3D, src: *const SkPoint3D, dst: *mut SkPoint3D);
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkMatrix3D9mapVectorERK9SkPoint3DPS0_"]
    pub fn SkMatrix3D_mapVector(
        this: *const SkMatrix3D,
        src: *const SkVector3D,
        dst: *mut SkVector3D,
    );
}
impl SkMatrix3D {
    #[inline]
    pub unsafe fn reset(&mut self) {
        SkMatrix3D_reset(self)
    }
    #[inline]
    pub unsafe fn setRotateX(&mut self, deg: SkScalar) {
        SkMatrix3D_setRotateX(self, deg)
    }
    #[inline]
    pub unsafe fn setRotateY(&mut self, deg: SkScalar) {
        SkMatrix3D_setRotateY(self, deg)
    }
    #[inline]
    pub unsafe fn setRotateZ(&mut self, deg: SkScalar) {
        SkMatrix3D_setRotateZ(self, deg)
    }
    #[inline]
    pub unsafe fn setTranslate(&mut self, x: SkScalar, y: SkScalar, z: SkScalar) {
        SkMatrix3D_setTranslate(self, x, y, z)
    }
    #[inline]
    pub unsafe fn preRotateX(&mut self, deg: SkScalar) {
        SkMatrix3D_preRotateX(self, deg)
    }
    #[inline]
    pub unsafe fn preRotateY(&mut self, deg: SkScalar) {
        SkMatrix3D_preRotateY(self, deg)
    }
    #[inline]
    pub unsafe fn preRotateZ(&mut self, deg: SkScalar) {
        SkMatrix3D_preRotateZ(self, deg)
    }
    #[inline]
    pub unsafe fn preTranslate(&mut self, x: SkScalar, y: SkScalar, z: SkScalar) {
        SkMatrix3D_preTranslate(self, x, y, z)
    }
    #[inline]
    pub unsafe fn setConcat(&mut self, a: *const SkMatrix3D, b: *const SkMatrix3D) {
        SkMatrix3D_setConcat(self, a, b)
    }
    #[inline]
    pub unsafe fn mapPoint(&self, src: *const SkPoint3D, dst: *mut SkPoint3D) {
        SkMatrix3D_mapPoint(self, src, dst)
    }
    #[inline]
    pub unsafe fn mapVector(&self, src: *const SkVector3D, dst: *mut SkVector3D) {
        SkMatrix3D_mapVector(self, src, dst)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkPatch3D {
    pub fU: SkVector3D,
    pub fV: SkVector3D,
    pub fOrigin: SkPoint3D,
}
#[test]
fn bindgen_test_layout_SkPatch3D() {
    assert_eq!(
        ::core::mem::size_of::<SkPatch3D>(),
        36usize,
        concat!("Size of: ", stringify!(SkPatch3D))
    );
    assert_eq!(
        ::core::mem::align_of::<SkPatch3D>(),
        4usize,
        concat!("Alignment of ", stringify!(SkPatch3D))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPatch3D>())).fU as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPatch3D),
            "::",
            stringify!(fU)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPatch3D>())).fV as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPatch3D),
            "::",
            stringify!(fV)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkPatch3D>())).fOrigin as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkPatch3D),
            "::",
            stringify!(fOrigin)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkPatch3D5resetEv"]
    pub fn SkPatch3D_reset(this: *mut SkPatch3D);
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkPatch3D9transformERK10SkMatrix3DPS_"]
    pub fn SkPatch3D_transform(
        this: *const SkPatch3D,
        arg1: *const SkMatrix3D,
        dst: *mut SkPatch3D,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK9SkPatch3D7dotWithEfff"]
    pub fn SkPatch3D_dotWith(
        this: *const SkPatch3D,
        dx: SkScalar,
        dy: SkScalar,
        dz: SkScalar,
    ) -> SkScalar;
}
extern "C" {
    #[link_name = "\u{1}_ZN9SkPatch3DC1Ev"]
    pub fn SkPatch3D_SkPatch3D(this: *mut SkPatch3D);
}
impl SkPatch3D {
    #[inline]
    pub unsafe fn reset(&mut self) {
        SkPatch3D_reset(self)
    }
    #[inline]
    pub unsafe fn transform(&self, arg1: *const SkMatrix3D, dst: *mut SkPatch3D) {
        SkPatch3D_transform(self, arg1, dst)
    }
    #[inline]
    pub unsafe fn dotWith(&self, dx: SkScalar, dy: SkScalar, dz: SkScalar) -> SkScalar {
        SkPatch3D_dotWith(self, dx, dy, dz)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkPatch3D_SkPatch3D(&mut __bindgen_tmp);
        __bindgen_tmp
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkCamera3D {
    pub fLocation: SkPoint3D,
    pub fAxis: SkPoint3D,
    pub fZenith: SkPoint3D,
    pub fObserver: SkPoint3D,
    pub fOrientation: SkMatrix,
    pub fNeedToUpdate: bool,
}
#[test]
fn bindgen_test_layout_SkCamera3D() {
    assert_eq!(
        ::core::mem::size_of::<SkCamera3D>(),
        92usize,
        concat!("Size of: ", stringify!(SkCamera3D))
    );
    assert_eq!(
        ::core::mem::align_of::<SkCamera3D>(),
        4usize,
        concat!("Alignment of ", stringify!(SkCamera3D))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCamera3D>())).fLocation as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCamera3D),
            "::",
            stringify!(fLocation)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCamera3D>())).fAxis as *const _ as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCamera3D),
            "::",
            stringify!(fAxis)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCamera3D>())).fZenith as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCamera3D),
            "::",
            stringify!(fZenith)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCamera3D>())).fObserver as *const _ as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCamera3D),
            "::",
            stringify!(fObserver)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCamera3D>())).fOrientation as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCamera3D),
            "::",
            stringify!(fOrientation)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkCamera3D>())).fNeedToUpdate as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(SkCamera3D),
            "::",
            stringify!(fNeedToUpdate)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkCamera3D5resetEv"]
    pub fn SkCamera3D_reset(this: *mut SkCamera3D);
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkCamera3D6updateEv"]
    pub fn SkCamera3D_update(this: *mut SkCamera3D);
}
extern "C" {
    #[link_name = "\u{1}_ZNK10SkCamera3D13patchToMatrixERK9SkPatch3DP8SkMatrix"]
    pub fn SkCamera3D_patchToMatrix(
        this: *const SkCamera3D,
        arg1: *const SkPatch3D,
        matrix: *mut SkMatrix,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN10SkCamera3DC1Ev"]
    pub fn SkCamera3D_SkCamera3D(this: *mut SkCamera3D);
}
impl SkCamera3D {
    #[inline]
    pub unsafe fn reset(&mut self) {
        SkCamera3D_reset(self)
    }
    #[inline]
    pub unsafe fn update(&mut self) {
        SkCamera3D_update(self)
    }
    #[inline]
    pub unsafe fn patchToMatrix(&self, arg1: *const SkPatch3D, matrix: *mut SkMatrix) {
        SkCamera3D_patchToMatrix(self, arg1, matrix)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkCamera3D_SkCamera3D(&mut __bindgen_tmp);
        __bindgen_tmp
    }
}
#[repr(C)]
pub struct Sk3DView {
    pub fRec: *mut Sk3DView_Rec,
    pub fInitialRec: Sk3DView_Rec,
    pub fCamera: SkCamera3D,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct Sk3DView_Rec {
    pub fNext: *mut Sk3DView_Rec,
    pub fMatrix: SkMatrix3D,
}
#[test]
fn bindgen_test_layout_Sk3DView_Rec() {
    assert_eq!(
        ::core::mem::size_of::<Sk3DView_Rec>(),
        56usize,
        concat!("Size of: ", stringify!(Sk3DView_Rec))
    );
    assert_eq!(
        ::core::mem::align_of::<Sk3DView_Rec>(),
        8usize,
        concat!("Alignment of ", stringify!(Sk3DView_Rec))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<Sk3DView_Rec>())).fNext as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(Sk3DView_Rec),
            "::",
            stringify!(fNext)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<Sk3DView_Rec>())).fMatrix as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(Sk3DView_Rec),
            "::",
            stringify!(fMatrix)
        )
    );
}
#[test]
fn bindgen_test_layout_Sk3DView() {
    assert_eq!(
        ::core::mem::size_of::<Sk3DView>(),
        160usize,
        concat!("Size of: ", stringify!(Sk3DView))
    );
    assert_eq!(
        ::core::mem::align_of::<Sk3DView>(),
        8usize,
        concat!("Alignment of ", stringify!(Sk3DView))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<Sk3DView>())).fRec as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(Sk3DView),
            "::",
            stringify!(fRec)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<Sk3DView>())).fInitialRec as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(Sk3DView),
            "::",
            stringify!(fInitialRec)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<Sk3DView>())).fCamera as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(Sk3DView),
            "::",
            stringify!(fCamera)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN8Sk3DView4saveEv"]
    pub fn Sk3DView_save(this: *mut Sk3DView);
}
extern "C" {
    #[link_name = "\u{1}_ZN8Sk3DView7restoreEv"]
    pub fn Sk3DView_restore(this: *mut Sk3DView);
}
extern "C" {
    #[link_name = "\u{1}_ZN8Sk3DView9translateEfff"]
    pub fn Sk3DView_translate(this: *mut Sk3DView, x: SkScalar, y: SkScalar, z: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN8Sk3DView7rotateXEf"]
    pub fn Sk3DView_rotateX(this: *mut Sk3DView, deg: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN8Sk3DView7rotateYEf"]
    pub fn Sk3DView_rotateY(this: *mut Sk3DView, deg: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZN8Sk3DView7rotateZEf"]
    pub fn Sk3DView_rotateZ(this: *mut Sk3DView, deg: SkScalar);
}
extern "C" {
    #[link_name = "\u{1}_ZNK8Sk3DView9getMatrixEP8SkMatrix"]
    pub fn Sk3DView_getMatrix(this: *const Sk3DView, arg1: *mut SkMatrix);
}
extern "C" {
    #[link_name = "\u{1}_ZNK8Sk3DView13applyToCanvasEP8SkCanvas"]
    pub fn Sk3DView_applyToCanvas(this: *const Sk3DView, arg1: *mut SkCanvas);
}
extern "C" {
    #[link_name = "\u{1}_ZNK8Sk3DView13dotWithNormalEfff"]
    pub fn Sk3DView_dotWithNormal(
        this: *const Sk3DView,
        dx: SkScalar,
        dy: SkScalar,
        dz: SkScalar,
    ) -> SkScalar;
}
extern "C" {
    #[link_name = "\u{1}_ZN8Sk3DViewC1Ev"]
    pub fn Sk3DView_Sk3DView(this: *mut Sk3DView);
}
extern "C" {
    #[link_name = "\u{1}_ZN8Sk3DViewD1Ev"]
    pub fn Sk3DView_Sk3DView_destructor(this: *mut Sk3DView);
}
impl Sk3DView {
    #[inline]
    pub unsafe fn save(&mut self) {
        Sk3DView_save(self)
    }
    #[inline]
    pub unsafe fn restore(&mut self) {
        Sk3DView_restore(self)
    }
    #[inline]
    pub unsafe fn translate(&mut self, x: SkScalar, y: SkScalar, z: SkScalar) {
        Sk3DView_translate(self, x, y, z)
    }
    #[inline]
    pub unsafe fn rotateX(&mut self, deg: SkScalar) {
        Sk3DView_rotateX(self, deg)
    }
    #[inline]
    pub unsafe fn rotateY(&mut self, deg: SkScalar) {
        Sk3DView_rotateY(self, deg)
    }
    #[inline]
    pub unsafe fn rotateZ(&mut self, deg: SkScalar) {
        Sk3DView_rotateZ(self, deg)
    }
    #[inline]
    pub unsafe fn getMatrix(&self, arg1: *mut SkMatrix) {
        Sk3DView_getMatrix(self, arg1)
    }
    #[inline]
    pub unsafe fn applyToCanvas(&self, arg1: *mut SkCanvas) {
        Sk3DView_applyToCanvas(self, arg1)
    }
    #[inline]
    pub unsafe fn dotWithNormal(&self, dx: SkScalar, dy: SkScalar, dz: SkScalar) -> SkScalar {
        Sk3DView_dotWithNormal(self, dx, dy, dz)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        Sk3DView_Sk3DView(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        Sk3DView_Sk3DView_destructor(self)
    }
}
#[repr(C)]
pub struct SkInterpolatorBase {
    pub fFrameCount: i16,
    pub fElemCount: u8,
    pub fFlags: u8,
    pub fRepeat: SkScalar,
    pub fTimes: *mut SkInterpolatorBase_SkTimeCode,
    pub fStorage: *mut ::std::os::raw::c_void,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkInterpolatorBase_Result {
    kNormal_Result = 0,
    kFreezeStart_Result = 1,
    kFreezeEnd_Result = 2,
}
pub const SkInterpolatorBase_Flags_kMirror: SkInterpolatorBase_Flags = 1;
pub const SkInterpolatorBase_Flags_kReset: SkInterpolatorBase_Flags = 2;
pub const SkInterpolatorBase_Flags_kHasBlend: SkInterpolatorBase_Flags = 4;
pub type SkInterpolatorBase_Flags = u32;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkInterpolatorBase_SkTimeCode {
    pub fTime: SkMSec,
    pub fBlend: [SkScalar; 4usize],
}
#[test]
fn bindgen_test_layout_SkInterpolatorBase_SkTimeCode() {
    assert_eq!(
        ::core::mem::size_of::<SkInterpolatorBase_SkTimeCode>(),
        20usize,
        concat!("Size of: ", stringify!(SkInterpolatorBase_SkTimeCode))
    );
    assert_eq!(
        ::core::mem::align_of::<SkInterpolatorBase_SkTimeCode>(),
        4usize,
        concat!("Alignment of ", stringify!(SkInterpolatorBase_SkTimeCode))
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkInterpolatorBase_SkTimeCode>())).fTime as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkInterpolatorBase_SkTimeCode),
            "::",
            stringify!(fTime)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::core::ptr::null::<SkInterpolatorBase_SkTimeCode>())).fBlend as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkInterpolatorBase_SkTimeCode),
            "::",
            stringify!(fBlend)
        )
    );
}
#[test]
fn bindgen_test_layout_SkInterpolatorBase() {
    assert_eq!(
        ::core::mem::size_of::<SkInterpolatorBase>(),
        24usize,
        concat!("Size of: ", stringify!(SkInterpolatorBase))
    );
    assert_eq!(
        ::core::mem::align_of::<SkInterpolatorBase>(),
        8usize,
        concat!("Alignment of ", stringify!(SkInterpolatorBase))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkInterpolatorBase>())).fFrameCount as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(SkInterpolatorBase),
            "::",
            stringify!(fFrameCount)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkInterpolatorBase>())).fElemCount as *const _ as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(SkInterpolatorBase),
            "::",
            stringify!(fElemCount)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkInterpolatorBase>())).fFlags as *const _ as usize },
        3usize,
        concat!(
            "Offset of field: ",
            stringify!(SkInterpolatorBase),
            "::",
            stringify!(fFlags)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkInterpolatorBase>())).fRepeat as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(SkInterpolatorBase),
            "::",
            stringify!(fRepeat)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkInterpolatorBase>())).fTimes as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(SkInterpolatorBase),
            "::",
            stringify!(fTimes)
        )
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkInterpolatorBase>())).fStorage as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(SkInterpolatorBase),
            "::",
            stringify!(fStorage)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN18SkInterpolatorBase5resetEii"]
    pub fn SkInterpolatorBase_reset(
        this: *mut SkInterpolatorBase,
        elemCount: ::std::os::raw::c_int,
        frameCount: ::std::os::raw::c_int,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZNK18SkInterpolatorBase11getDurationEPjS0_"]
    pub fn SkInterpolatorBase_getDuration(
        this: *const SkInterpolatorBase,
        startTime: *mut SkMSec,
        endTime: *mut SkMSec,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK18SkInterpolatorBase7timeToTEjPfPiPb"]
    pub fn SkInterpolatorBase_timeToT(
        this: *const SkInterpolatorBase,
        time: SkMSec,
        T: *mut SkScalar,
        index: *mut ::std::os::raw::c_int,
        exact: *mut bool,
    ) -> SkInterpolatorBase_Result;
}
extern "C" {
    #[link_name = "\u{1}_ZN18SkInterpolatorBase16ComputeRelativeTEjjjPKf"]
    pub fn SkInterpolatorBase_ComputeRelativeT(
        time: SkMSec,
        prevTime: SkMSec,
        nextTime: SkMSec,
        blend: *const SkScalar,
    ) -> SkScalar;
}
extern "C" {
    #[link_name = "\u{1}_ZN18SkInterpolatorBaseC1Ev"]
    pub fn SkInterpolatorBase_SkInterpolatorBase(this: *mut SkInterpolatorBase);
}
extern "C" {
    #[link_name = "\u{1}_ZN18SkInterpolatorBaseD1Ev"]
    pub fn SkInterpolatorBase_SkInterpolatorBase_destructor(this: *mut SkInterpolatorBase);
}
impl SkInterpolatorBase {
    #[inline]
    pub unsafe fn reset(
        &mut self,
        elemCount: ::std::os::raw::c_int,
        frameCount: ::std::os::raw::c_int,
    ) {
        SkInterpolatorBase_reset(self, elemCount, frameCount)
    }
    #[inline]
    pub unsafe fn getDuration(&self, startTime: *mut SkMSec, endTime: *mut SkMSec) -> bool {
        SkInterpolatorBase_getDuration(self, startTime, endTime)
    }
    #[inline]
    pub unsafe fn timeToT(
        &self,
        time: SkMSec,
        T: *mut SkScalar,
        index: *mut ::std::os::raw::c_int,
        exact: *mut bool,
    ) -> SkInterpolatorBase_Result {
        SkInterpolatorBase_timeToT(self, time, T, index, exact)
    }
    #[inline]
    pub unsafe fn ComputeRelativeT(
        time: SkMSec,
        prevTime: SkMSec,
        nextTime: SkMSec,
        blend: *const SkScalar,
    ) -> SkScalar {
        SkInterpolatorBase_ComputeRelativeT(time, prevTime, nextTime, blend)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkInterpolatorBase_SkInterpolatorBase(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn destruct(&mut self) {
        SkInterpolatorBase_SkInterpolatorBase_destructor(self)
    }
}
#[repr(C)]
pub struct SkInterpolator {
    pub _base: SkInterpolatorBase,
    pub fValues: *mut SkScalar,
}
pub type SkInterpolator_INHERITED = SkInterpolatorBase;
#[test]
fn bindgen_test_layout_SkInterpolator() {
    assert_eq!(
        ::core::mem::size_of::<SkInterpolator>(),
        32usize,
        concat!("Size of: ", stringify!(SkInterpolator))
    );
    assert_eq!(
        ::core::mem::align_of::<SkInterpolator>(),
        8usize,
        concat!("Alignment of ", stringify!(SkInterpolator))
    );
    assert_eq!(
        unsafe { &(*(::core::ptr::null::<SkInterpolator>())).fValues as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(SkInterpolator),
            "::",
            stringify!(fValues)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkInterpolator5resetEii"]
    pub fn SkInterpolator_reset(
        this: *mut SkInterpolator,
        elemCount: ::std::os::raw::c_int,
        frameCount: ::std::os::raw::c_int,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkInterpolator11setKeyFrameEijPKfS1_"]
    pub fn SkInterpolator_setKeyFrame(
        this: *mut SkInterpolator,
        index: ::std::os::raw::c_int,
        time: SkMSec,
        values: *const SkScalar,
        blend: *const SkScalar,
    ) -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZNK14SkInterpolator12timeToValuesEjPf"]
    pub fn SkInterpolator_timeToValues(
        this: *const SkInterpolator,
        time: SkMSec,
        values: *mut SkScalar,
    ) -> SkInterpolatorBase_Result;
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkInterpolatorC1Ev"]
    pub fn SkInterpolator_SkInterpolator(this: *mut SkInterpolator);
}
extern "C" {
    #[link_name = "\u{1}_ZN14SkInterpolatorC1Eii"]
    pub fn SkInterpolator_SkInterpolator1(
        this: *mut SkInterpolator,
        elemCount: ::std::os::raw::c_int,
        frameCount: ::std::os::raw::c_int,
    );
}
impl SkInterpolator {
    #[inline]
    pub unsafe fn reset(
        &mut self,
        elemCount: ::std::os::raw::c_int,
        frameCount: ::std::os::raw::c_int,
    ) {
        SkInterpolator_reset(self, elemCount, frameCount)
    }
    #[inline]
    pub unsafe fn setKeyFrame(
        &mut self,
        index: ::std::os::raw::c_int,
        time: SkMSec,
        values: *const SkScalar,
        blend: *const SkScalar,
    ) -> bool {
        SkInterpolator_setKeyFrame(self, index, time, values, blend)
    }
    #[inline]
    pub unsafe fn timeToValues(
        &self,
        time: SkMSec,
        values: *mut SkScalar,
    ) -> SkInterpolatorBase_Result {
        SkInterpolator_timeToValues(self, time, values)
    }
    #[inline]
    pub unsafe fn new() -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkInterpolator_SkInterpolator(&mut __bindgen_tmp);
        __bindgen_tmp
    }
    #[inline]
    pub unsafe fn new1(
        elemCount: ::std::os::raw::c_int,
        frameCount: ::std::os::raw::c_int,
    ) -> Self {
        let mut __bindgen_tmp = ::core::mem::uninitialized();
        SkInterpolator_SkInterpolator1(&mut __bindgen_tmp, elemCount, frameCount);
        __bindgen_tmp
    }
}
extern "C" {
    #[link_name = "\u{1}_Z17SkUnitCubicInterpfffff"]
    pub fn SkUnitCubicInterp(
        value: SkScalar,
        bx: SkScalar,
        by: SkScalar,
        cx: SkScalar,
        cy: SkScalar,
    ) -> SkScalar;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkParsePath {
    pub _address: u8,
}
#[test]
fn bindgen_test_layout_SkParsePath() {
    assert_eq!(
        ::core::mem::size_of::<SkParsePath>(),
        1usize,
        concat!("Size of: ", stringify!(SkParsePath))
    );
    assert_eq!(
        ::core::mem::align_of::<SkParsePath>(),
        1usize,
        concat!("Alignment of ", stringify!(SkParsePath))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkParsePath13FromSVGStringEPKcP6SkPath"]
    pub fn SkParsePath_FromSVGString(str: *const ::std::os::raw::c_char, arg1: *mut SkPath)
        -> bool;
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkParsePath11ToSVGStringERK6SkPathP8SkString"]
    pub fn SkParsePath_ToSVGString(arg1: *const SkPath, arg2: *mut SkString);
}
impl SkParsePath {
    #[inline]
    pub unsafe fn FromSVGString(str: *const ::std::os::raw::c_char, arg1: *mut SkPath) -> bool {
        SkParsePath_FromSVGString(str, arg1)
    }
    #[inline]
    pub unsafe fn ToSVGString(arg1: *const SkPath, arg2: *mut SkString) {
        SkParsePath_ToSVGString(arg1, arg2)
    }
}
pub const SkShadowFlags_kNone_ShadowFlag: SkShadowFlags = 0;
pub const SkShadowFlags_kTransparentOccluder_ShadowFlag: SkShadowFlags = 1;
pub const SkShadowFlags_kGeometricOnly_ShadowFlag: SkShadowFlags = 2;
pub const SkShadowFlags_kAll_ShadowFlag: SkShadowFlags = 3;
pub type SkShadowFlags = u32;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkShadowUtils {
    pub _address: u8,
}
#[test]
fn bindgen_test_layout_SkShadowUtils() {
    assert_eq!(
        ::core::mem::size_of::<SkShadowUtils>(),
        1usize,
        concat!("Size of: ", stringify!(SkShadowUtils))
    );
    assert_eq!(
        ::core::mem::align_of::<SkShadowUtils>(),
        1usize,
        concat!("Alignment of ", stringify!(SkShadowUtils))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkShadowUtils10DrawShadowEP8SkCanvasRK6SkPathRK8SkPoint3S7_fjjj"]
    pub fn SkShadowUtils_DrawShadow(
        canvas: *mut SkCanvas,
        path: *const SkPath,
        zPlaneParams: *const SkPoint3,
        lightPos: *const SkPoint3,
        lightRadius: SkScalar,
        ambientColor: SkColor,
        spotColor: SkColor,
        flags: u32,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN13SkShadowUtils18ComputeTonalColorsEjjPjS0_"]
    pub fn SkShadowUtils_ComputeTonalColors(
        inAmbientColor: SkColor,
        inSpotColor: SkColor,
        outAmbientColor: *mut SkColor,
        outSpotColor: *mut SkColor,
    );
}
impl SkShadowUtils {
    #[inline]
    pub unsafe fn DrawShadow(
        canvas: *mut SkCanvas,
        path: *const SkPath,
        zPlaneParams: *const SkPoint3,
        lightPos: *const SkPoint3,
        lightRadius: SkScalar,
        ambientColor: SkColor,
        spotColor: SkColor,
        flags: u32,
    ) {
        SkShadowUtils_DrawShadow(
            canvas,
            path,
            zPlaneParams,
            lightPos,
            lightRadius,
            ambientColor,
            spotColor,
            flags,
        )
    }
    #[inline]
    pub unsafe fn ComputeTonalColors(
        inAmbientColor: SkColor,
        inSpotColor: SkColor,
        outAmbientColor: *mut SkColor,
        outSpotColor: *mut SkColor,
    ) {
        SkShadowUtils_ComputeTonalColors(inAmbientColor, inSpotColor, outAmbientColor, outSpotColor)
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkTextUtils {
    pub _address: u8,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum SkTextUtils_Align {
    kLeft_Align = 0,
    kCenter_Align = 1,
    kRight_Align = 2,
}
#[test]
fn bindgen_test_layout_SkTextUtils() {
    assert_eq!(
        ::core::mem::size_of::<SkTextUtils>(),
        1usize,
        concat!("Size of: ", stringify!(SkTextUtils))
    );
    assert_eq!(
        ::core::mem::align_of::<SkTextUtils>(),
        1usize,
        concat!("Alignment of ", stringify!(SkTextUtils))
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkTextUtils4DrawEP8SkCanvasPKvm14SkTextEncodingffRK6SkFontRK7SkPaintNS_5AlignE"]
    pub fn SkTextUtils_Draw(
        arg1: *mut SkCanvas,
        text: *const ::std::os::raw::c_void,
        size: usize,
        arg2: SkTextEncoding,
        x: SkScalar,
        y: SkScalar,
        arg3: *const SkFont,
        arg4: *const SkPaint,
        arg5: SkTextUtils_Align,
    );
}
extern "C" {
    #[link_name = "\u{1}_ZN11SkTextUtils7GetPathEPKvm14SkTextEncodingffRK6SkFontP6SkPath"]
    pub fn SkTextUtils_GetPath(
        text: *const ::std::os::raw::c_void,
        length: usize,
        arg1: SkTextEncoding,
        x: SkScalar,
        y: SkScalar,
        arg2: *const SkFont,
        arg3: *mut SkPath,
    );
}
impl SkTextUtils {
    #[inline]
    pub unsafe fn Draw(
        arg1: *mut SkCanvas,
        text: *const ::std::os::raw::c_void,
        size: usize,
        arg2: SkTextEncoding,
        x: SkScalar,
        y: SkScalar,
        arg3: *const SkFont,
        arg4: *const SkPaint,
        arg5: SkTextUtils_Align,
    ) {
        SkTextUtils_Draw(arg1, text, size, arg2, x, y, arg3, arg4, arg5)
    }
    #[inline]
    pub unsafe fn GetPath(
        text: *const ::std::os::raw::c_void,
        length: usize,
        arg1: SkTextEncoding,
        x: SkScalar,
        y: SkScalar,
        arg2: *const SkFont,
        arg3: *mut SkPath,
    ) {
        SkTextUtils_GetPath(text, length, arg1, x, y, arg2, arg3)
    }
}
extern "C" {
    pub fn C_SkEncodedOriginToMatrix(
        origin: SkEncodedOrigin,
        w: ::std::os::raw::c_int,
        h: ::std::os::raw::c_int,
        matrix: *mut SkMatrix,
    );
}
extern "C" {
    pub fn C_SkSurface_MakeRasterDirect(
        imageInfo: *const SkImageInfo,
        pixels: *mut ::std::os::raw::c_void,
        rowBytes: usize,
        surfaceProps: *const SkSurfaceProps,
    ) -> *mut SkSurface;
}
extern "C" {
    pub fn C_SkSurface_MakeRaster(
        imageInfo: *const SkImageInfo,
        rowBytes: usize,
        surfaceProps: *const SkSurfaceProps,
    ) -> *mut SkSurface;
}
extern "C" {
    pub fn C_SkSurface_MakeRasterN32Premul(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        surfaceProps: *const SkSurfaceProps,
    ) -> *mut SkSurface;
}
extern "C" {
    pub fn C_SkSurface_MakeFromBackendTexture(
        context: *mut GrContext,
        backendTexture: *const GrBackendTexture,
        origin: GrSurfaceOrigin,
        sampleCnt: ::std::os::raw::c_int,
        colorType: SkColorType,
        colorSpace: *mut SkColorSpace,
        surfaceProps: *const SkSurfaceProps,
    ) -> *mut SkSurface;
}
extern "C" {
    pub fn C_SkSurface_MakeFromBackendRenderTarget(
        context: *mut GrContext,
        backendRenderTarget: *const GrBackendRenderTarget,
        origin: GrSurfaceOrigin,
        colorType: SkColorType,
        colorSpace: *mut SkColorSpace,
        surfaceProps: *const SkSurfaceProps,
    ) -> *mut SkSurface;
}
extern "C" {
    pub fn C_SkSurface_MakeFromBackendTextureAsRenderTarget(
        context: *mut GrContext,
        backendTexture: *const GrBackendTexture,
        origin: GrSurfaceOrigin,
        sampleCnt: ::std::os::raw::c_int,
        colorType: SkColorType,
        colorSpace: *mut SkColorSpace,
        surfaceProps: *const SkSurfaceProps,
    ) -> *mut SkSurface;
}
extern "C" {
    pub fn C_SkSurface_MakeRenderTarget(
        context: *mut GrContext,
        budgeted: SkBudgeted,
        imageInfo: *const SkImageInfo,
        sampleCount: ::std::os::raw::c_int,
        surfaceOrigin: GrSurfaceOrigin,
        surfaceProps: *const SkSurfaceProps,
        shouldCreateWithMips: bool,
    ) -> *mut SkSurface;
}
extern "C" {
    pub fn C_SkSurface_MakeRenderTarget2(
        context: *mut GrContext,
        characterization: *const SkSurfaceCharacterization,
        budgeted: SkBudgeted,
    ) -> *mut SkSurface;
}
extern "C" {
    pub fn C_SkSurface_MakeFromBackendTexture2(
        context: *mut GrContext,
        characterization: *const SkSurfaceCharacterization,
        backendTexture: *const GrBackendTexture,
    ) -> *mut SkSurface;
}
extern "C" {
    pub fn C_SkSurface_MakeNull(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
    ) -> *mut SkSurface;
}
extern "C" {
    pub fn C_SkSurface_width(self_: *const SkSurface) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn C_SkSurface_height(self_: *const SkSurface) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn C_SkSurface_imageInfo(self_: *mut SkSurface, info: *mut SkImageInfo);
}
extern "C" {
    pub fn C_SkSurface_makeImageSnapshot(
        self_: *mut SkSurface,
        bounds: *const SkIRect,
    ) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkSurface_getBackendTexture(
        self_: *mut SkSurface,
        handleAccess: SkSurface_BackendHandleAccess,
        backendTexture: *mut GrBackendTexture,
    );
}
extern "C" {
    pub fn C_SkSurface_getBackendRenderTarget(
        self_: *mut SkSurface,
        handleAccess: SkSurface_BackendHandleAccess,
        backendRenderTarget: *mut GrBackendRenderTarget,
    );
}
extern "C" {
    pub fn C_SkSurface_makeSurface(
        self_: *mut SkSurface,
        imageInfo: *const SkImageInfo,
    ) -> *mut SkSurface;
}
extern "C" {
    pub fn C_SkSurface_makeSurface2(
        self_: *mut SkSurface,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
    ) -> *mut SkSurface;
}
extern "C" {
    pub fn C_SkSurface_props(self_: *const SkSurface) -> *const SkSurfaceProps;
}
extern "C" {
    pub fn C_SkSurfaceCharacterization_Construct(uninitialized: *mut SkSurfaceCharacterization);
}
extern "C" {
    pub fn C_SkSurfaceCharacterization_CopyConstruct(
        uninitialized: *mut SkSurfaceCharacterization,
        from: *const SkSurfaceCharacterization,
    );
}
extern "C" {
    pub fn C_SkSurfaceCharacterization_destruct(self_: *mut SkSurfaceCharacterization);
}
extern "C" {
    pub fn C_SkSurfaceCharacterization_equals(
        self_: *const SkSurfaceCharacterization,
        rhs: *const SkSurfaceCharacterization,
    ) -> bool;
}
extern "C" {
    pub fn C_SkSurfaceCharacterization_imageInfo(
        self_: *const SkSurfaceCharacterization,
    ) -> *const SkImageInfo;
}
extern "C" {
    pub fn C_SkImage_MakeRasterData(
        info: *const SkImageInfo,
        pixels: *mut SkData,
        rowBytes: usize,
    ) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkImage_MakeFromBitmap(bitmap: *const SkBitmap) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkImage_MakeFromGenerator(
        imageGenerator: *mut SkImageGenerator,
        subset: *const SkIRect,
    ) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkImage_MakeFromEncoded(encoded: *mut SkData, subset: *const SkIRect) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkImage_MakeFromCompressed(
        context: *mut GrContext,
        encoded: *mut SkData,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        type_: SkImage_CompressionType,
    ) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkImage_MakeFromTexture(
        context: *mut GrContext,
        backendTexture: *const GrBackendTexture,
        origin: GrSurfaceOrigin,
        colorType: SkColorType,
        alphaType: SkAlphaType,
        colorSpace: *mut SkColorSpace,
    ) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkImage_MakeCrossContextFromEncoded(
        context: *mut GrContext,
        data: *mut SkData,
        buildMips: bool,
        dstColorSpace: *const SkColorSpace,
        limitToMaxTextureSize: bool,
    ) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkImage_MakeFromAdoptedTexture(
        context: *mut GrContext,
        backendTexture: *const GrBackendTexture,
        origin: GrSurfaceOrigin,
        colorType: SkColorType,
        alphaType: SkAlphaType,
        colorSpace: *mut SkColorSpace,
    ) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkImage_MakeFromYUVATexturesCopy(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        yuvaTextures: *const GrBackendTexture,
        yuvaIndices: *const SkYUVAIndex,
        imageSize: SkISize,
        imageOrigin: GrSurfaceOrigin,
        colorSpace: *mut SkColorSpace,
    ) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkImage_MakeFromYUVATexturesCopyWithExternalBackend(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        yuvaTextures: *const GrBackendTexture,
        yuvaIndices: *const SkYUVAIndex,
        imageSize: SkISize,
        imageOrigin: GrSurfaceOrigin,
        backendTexture: *const GrBackendTexture,
        colorSpace: *mut SkColorSpace,
    ) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkImage_MakeFromYUVATextures(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        yuvaTextures: *const GrBackendTexture,
        yuvaIndices: *const SkYUVAIndex,
        imageSize: SkISize,
        imageOrigin: GrSurfaceOrigin,
        colorSpace: *mut SkColorSpace,
    ) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkImage_MakeFromNV12TexturesCopy(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        nv12Textures: *const GrBackendTexture,
        imageOrigin: GrSurfaceOrigin,
        imageColorSpace: *mut SkColorSpace,
    ) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkImage_MakeFromNV12TexturesCopyWithExternalBackend(
        context: *mut GrContext,
        yuvColorSpace: SkYUVColorSpace,
        nv12Textures: *const GrBackendTexture,
        imageOrigin: GrSurfaceOrigin,
        backendTexture: *const GrBackendTexture,
        imageColorSpace: *mut SkColorSpace,
    ) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkImage_MakeFromPicture(
        picture: *mut SkPicture,
        dimensions: *const SkISize,
        matrix: *const SkMatrix,
        paint: *const SkPaint,
        bitDepth: SkImage_BitDepth,
        colorSpace: *mut SkColorSpace,
    ) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkImage_makeShader(
        self_: *const SkImage,
        tileMode1: SkTileMode,
        tileMode2: SkTileMode,
        localMatrix: *const SkMatrix,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkImage_getBackendTexture(
        self_: *const SkImage,
        flushPendingGrContextIO: bool,
        origin: *mut GrSurfaceOrigin,
        result: *mut GrBackendTexture,
    );
}
extern "C" {
    pub fn C_SkImage_encodeToData(
        self_: *const SkImage,
        imageFormat: SkEncodedImageFormat,
    ) -> *mut SkData;
}
extern "C" {
    pub fn C_SkImage_refEncodedData(self_: *const SkImage) -> *mut SkData;
}
extern "C" {
    pub fn C_SkImage_makeSubset(self_: *const SkImage, subset: *const SkIRect) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkImage_makeTextureImage(
        self_: *const SkImage,
        context: *mut GrContext,
        dstColorSpace: *const SkColorSpace,
        mipMapped: GrMipMapped,
    ) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkImage_makeNonTextureImage(self_: *const SkImage) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkImage_makeRasterImage(self_: *const SkImage) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkImage_makeWithFilter(
        self_: *const SkImage,
        context: *mut GrContext,
        filter: *const SkImageFilter,
        subset: *const SkIRect,
        clipBounds: *const SkIRect,
        outSubset: *mut SkIRect,
        offset: *mut SkIPoint,
    ) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkImage_makeColorSpace(
        self_: *const SkImage,
        target: *mut SkColorSpace,
    ) -> *mut SkImage;
}
extern "C" {
    pub fn C_SkEncodePixmap(
        src: *const SkPixmap,
        format: SkEncodedImageFormat,
        quality: ::std::os::raw::c_int,
    ) -> *mut SkData;
}
extern "C" {
    pub fn C_SkEncodeBitmap(
        src: *const SkBitmap,
        format: SkEncodedImageFormat,
        quality: ::std::os::raw::c_int,
    ) -> *mut SkData;
}
extern "C" {
    pub fn C_SkData_ref(self_: *const SkData);
}
extern "C" {
    pub fn C_SkData_unref(self_: *const SkData);
}
extern "C" {
    pub fn C_SkData_unique(self_: *const SkData) -> bool;
}
extern "C" {
    pub fn C_SkData_MakeWithCopy(data: *const ::std::os::raw::c_void, length: usize)
        -> *mut SkData;
}
extern "C" {
    pub fn C_SkData_MakeSubset(src: *const SkData, offset: usize, length: usize) -> *mut SkData;
}
extern "C" {
    pub fn C_SkData_MakeUninitialized(length: usize) -> *mut SkData;
}
extern "C" {
    pub fn C_SkData_MakeWithCString(cstr: *const ::std::os::raw::c_char) -> *mut SkData;
}
extern "C" {
    pub fn C_SkData_MakeWithoutCopy(
        data: *const ::std::os::raw::c_void,
        length: usize,
    ) -> *mut SkData;
}
extern "C" {
    pub fn C_SkData_MakeEmpty() -> *mut SkData;
}
extern "C" {
    pub fn C_SkMultiPictureDraw_destruct(self_: *mut SkMultiPictureDraw);
}
extern "C" {
    pub fn C_SkPaint_destruct(self_: *mut SkPaint);
}
extern "C" {
    pub fn C_SkPaint_copy(self_: *mut SkPaint, rhs: *const SkPaint);
}
extern "C" {
    pub fn C_SkPaint_Equals(lhs: *const SkPaint, rhs: *const SkPaint) -> bool;
}
extern "C" {
    pub fn C_SkPaint_getFilterQuality(self_: *const SkPaint) -> SkFilterQuality;
}
extern "C" {
    pub fn C_SkPaint_getStyle(self_: *const SkPaint) -> SkPaint_Style;
}
extern "C" {
    pub fn C_SkPaint_getAlpha(self_: *const SkPaint) -> u8;
}
extern "C" {
    pub fn C_SkPaint_getStrokeCap(self_: *const SkPaint) -> SkPaint_Cap;
}
extern "C" {
    pub fn C_SkPaint_getStrokeJoin(self_: *const SkPaint) -> SkPaint_Join;
}
extern "C" {
    pub fn C_SkPaint_setShader(self_: *mut SkPaint, shader: *mut SkShader);
}
extern "C" {
    pub fn C_SkPaint_setColorFilter(self_: *mut SkPaint, colorFilter: *mut SkColorFilter);
}
extern "C" {
    pub fn C_SkPaint_getBlendMode(self_: *const SkPaint) -> SkBlendMode;
}
extern "C" {
    pub fn C_SkPaint_setPathEffect(self_: *mut SkPaint, pathEffect: *mut SkPathEffect);
}
extern "C" {
    pub fn C_SkPaint_setMaskFilter(self_: *mut SkPaint, maskFilter: *mut SkMaskFilter);
}
extern "C" {
    pub fn C_SkPaint_setImageFilter(self_: *mut SkPaint, imageFilter: *mut SkImageFilter);
}
extern "C" {
    pub fn C_SkPath_destruct(self_: *const SkPath);
}
extern "C" {
    pub fn C_SkPath_Equals(lhs: *const SkPath, rhs: *const SkPath) -> bool;
}
extern "C" {
    pub fn C_SkPath_serialize(self_: *const SkPath) -> *mut SkData;
}
extern "C" {
    pub fn C_SkPath_ConvertToNonInverseFillType(fill: SkPath_FillType) -> SkPath_FillType;
}
extern "C" {
    pub fn C_SkPath_isValid(self_: *const SkPath) -> bool;
}
extern "C" {
    pub fn C_SkPath_Iter_destruct(self_: *mut SkPath_Iter);
}
extern "C" {
    pub fn C_SkPath_Iter_next(
        self_: *mut SkPath_Iter,
        pts: *mut SkPoint,
        doConsumeDegenerates: bool,
        exact: bool,
    ) -> SkPath_Verb;
}
extern "C" {
    pub fn C_SkPath_Iter_isCloseLine(self_: *const SkPath_Iter) -> bool;
}
extern "C" {
    pub fn C_SkPath_RawIter_Construct(uninitialized: *mut SkPath_RawIter);
}
extern "C" {
    pub fn C_SkPath_RawIter_destruct(self_: *mut SkPath_RawIter);
}
extern "C" {
    pub fn C_SkPath_RawIter_next(self_: *mut SkPath_RawIter, pts: *mut SkPoint) -> SkPath_Verb;
}
extern "C" {
    pub fn C_SkPath_RawIter_peek(self_: *const SkPath_RawIter) -> SkPath_Verb;
}
extern "C" {
    pub fn C_SkPath_getFillType(self_: *const SkPath) -> SkPath_FillType;
}
extern "C" {
    pub fn C_SkPath_getConvexity(self_: *const SkPath) -> SkPath_Convexity;
}
extern "C" {
    pub fn C_SkPath_getConvexityOrUnknown(self_: *const SkPath) -> SkPath_Convexity;
}
extern "C" {
    pub fn C_SkPath_isEmpty(self_: *const SkPath) -> bool;
}
extern "C" {
    pub fn C_SkPath_isFinite(self_: *const SkPath) -> bool;
}
extern "C" {
    pub fn C_SkPath_getBounds(self_: *const SkPath) -> *const SkRect;
}
extern "C" {
    pub fn C_SkPath_getSegmentMasks(self_: *const SkPath) -> u32;
}
extern "C" {
    pub fn C_SkPathMeasure_destruct(self_: *const SkPathMeasure);
}
extern "C" {
    pub fn C_SkCanvas_newEmpty() -> *mut SkCanvas;
}
extern "C" {
    pub fn C_SkCanvas_newWidthHeightAndProps(
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        props: *const SkSurfaceProps,
    ) -> *mut SkCanvas;
}
extern "C" {
    pub fn C_SkCanvas_newFromBitmap(bitmap: *const SkBitmap) -> *mut SkCanvas;
}
extern "C" {
    pub fn C_SkCanvas_newFromBitmapAndProps(
        bitmap: *const SkBitmap,
        props: *const SkSurfaceProps,
    ) -> *mut SkCanvas;
}
extern "C" {
    pub fn C_SkCanvas_delete(self_: *const SkCanvas);
}
extern "C" {
    pub fn C_SkCanvas_MakeRasterDirect(
        info: *const SkImageInfo,
        pixels: *mut ::std::os::raw::c_void,
        row_bytes: usize,
        props: *const SkSurfaceProps,
    ) -> *mut SkCanvas;
}
extern "C" {
    pub fn C_SkCanvas_imageInfo(self_: *const SkCanvas, info: *mut SkImageInfo);
}
extern "C" {
    pub fn C_SkCanvas_getBaseLayerSize(self_: *const SkCanvas, size: *mut SkISize);
}
extern "C" {
    pub fn C_SkCanvas_makeSurface(
        self_: *mut SkCanvas,
        info: *const SkImageInfo,
        props: *const SkSurfaceProps,
    ) -> *mut SkSurface;
}
extern "C" {
    pub fn C_SkCanvas_getGrContext(self_: *mut SkCanvas) -> *mut GrContext;
}
extern "C" {
    pub fn C_SkCanvas_isClipEmpty(self_: *const SkCanvas) -> bool;
}
extern "C" {
    pub fn C_SkCanvas_isClipRect(self_: *const SkCanvas) -> bool;
}
extern "C" {
    pub fn C_SkCanvas_discard(self_: *mut SkCanvas);
}
extern "C" {
    pub fn C_SkAutoCanvasRestore_Construct(
        uninitialized: *mut SkAutoCanvasRestore,
        canvas: *mut SkCanvas,
        doSave: bool,
    );
}
extern "C" {
    pub fn C_SkAutoCanvasRestore_destruct(self_: *const SkAutoCanvasRestore);
}
extern "C" {
    pub fn C_SkAutoCanvasRestore_restore(self_: *mut SkAutoCanvasRestore);
}
extern "C" {
    pub fn C_SkImageInfo_Construct(uninitialized: *mut SkImageInfo);
}
extern "C" {
    pub fn C_SkImageInfo_destruct(self_: *mut SkImageInfo);
}
extern "C" {
    pub fn C_SkImageInfo_Copy(from: *const SkImageInfo, to: *mut SkImageInfo);
}
extern "C" {
    pub fn C_SkImageInfo_Equals(lhs: *const SkImageInfo, rhs: *const SkImageInfo) -> bool;
}
extern "C" {
    pub fn C_SkImageInfo_Make(
        self_: *mut SkImageInfo,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        ct: SkColorType,
        at: SkAlphaType,
        cs: *mut SkColorSpace,
    );
}
extern "C" {
    pub fn C_SkImageInfo_MakeS32(
        self_: *mut SkImageInfo,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        at: SkAlphaType,
    );
}
extern "C" {
    pub fn C_SkImageInfo_colorSpace(self_: *const SkImageInfo) -> *mut SkColorSpace;
}
extern "C" {
    pub fn C_SkImageInfo_gammaCloseToSRGB(self_: *const SkImageInfo) -> bool;
}
extern "C" {
    pub fn C_SkImageInfo_reset(self_: *mut SkImageInfo);
}
extern "C" {
    pub fn C_SkColorSpace_ref(self_: *const SkColorSpace);
}
extern "C" {
    pub fn C_SkColorSpace_unref(self_: *const SkColorSpace);
}
extern "C" {
    pub fn C_SkColorSpace_unique(self_: *const SkColorSpace) -> bool;
}
extern "C" {
    pub fn C_SkColorSpace_MakeSRGB() -> *mut SkColorSpace;
}
extern "C" {
    pub fn C_SkColorSpace_MakeSRGBLinear() -> *mut SkColorSpace;
}
extern "C" {
    pub fn C_SkColorSpace_makeLinearGamma(self_: *const SkColorSpace) -> *mut SkColorSpace;
}
extern "C" {
    pub fn C_SkColorSpace_makeSRGBGamma(self_: *const SkColorSpace) -> *mut SkColorSpace;
}
extern "C" {
    pub fn C_SkColorSpace_makeColorSpin(self_: *const SkColorSpace) -> *mut SkColorSpace;
}
extern "C" {
    pub fn C_SkColorSpace_serialize(self_: *const SkColorSpace) -> *mut SkData;
}
extern "C" {
    pub fn C_SkColorSpace_Deserialize(
        data: *const ::std::os::raw::c_void,
        length: usize,
    ) -> *mut SkColorSpace;
}
extern "C" {
    pub fn C_SkMatrix44_ConstructIdentity(uninitialized: *mut SkMatrix44);
}
extern "C" {
    pub fn C_SkMatrix44_ConstructNaN(uninitialized: *mut SkMatrix44);
}
extern "C" {
    pub fn C_SkMatrix44_Equals(self_: *const SkMatrix44, rhs: *const SkMatrix44) -> bool;
}
extern "C" {
    pub fn C_SkMatrix44_SkMatrix(self_: *const SkMatrix44, m: *mut SkMatrix);
}
extern "C" {
    pub fn C_SkMatrix44_Mul(
        self_: *const SkMatrix44,
        rhs: *const SkMatrix44,
        result: *mut SkMatrix44,
    );
}
extern "C" {
    pub fn C_SkMatrix44_MulV4(
        self_: *const SkMatrix44,
        rhs: *const SkVector4,
        result: *mut SkVector4,
    );
}
extern "C" {
    pub fn C_SkMatrix_Equals(self_: *const SkMatrix, rhs: *const SkMatrix) -> bool;
}
extern "C" {
    pub fn C_SkMatrix_SubscriptMut(self_: *mut SkMatrix, index: usize) -> *mut SkScalar;
}
extern "C" {
    pub fn C_SkMatrix_getType(self_: *const SkMatrix) -> SkMatrix_TypeMask;
}
extern "C" {
    pub fn C_SkMatrix_rectStaysRect(self_: *const SkMatrix) -> bool;
}
extern "C" {
    pub fn C_SkMatrix_hasPerspective(self_: *const SkMatrix) -> bool;
}
extern "C" {
    pub fn C_SkMatrix_invert(self_: *const SkMatrix, inverse: *mut SkMatrix) -> bool;
}
extern "C" {
    pub fn C_SkMatrix_cheapEqualTo(self_: *const SkMatrix, other: *const SkMatrix) -> bool;
}
extern "C" {
    pub fn C_SkMatrix_setScaleTranslate(
        self_: *mut SkMatrix,
        sx: SkScalar,
        sy: SkScalar,
        tx: SkScalar,
        ty: SkScalar,
    );
}
extern "C" {
    pub fn C_SkMatrix_isFinite(self_: *const SkMatrix) -> bool;
}
extern "C" {
    pub fn C_SkSurfaceProps_Equals(
        self_: *const SkSurfaceProps,
        rhs: *const SkSurfaceProps,
    ) -> bool;
}
extern "C" {
    pub fn C_SkBitmap_Construct(uninitialized: *mut SkBitmap);
}
extern "C" {
    pub fn C_SkBitmap_destruct(self_: *mut SkBitmap);
}
extern "C" {
    pub fn C_SkBitmap_Copy(from: *const SkBitmap, to: *mut SkBitmap);
}
extern "C" {
    pub fn C_SkBitmap_ComputeIsOpaque(self_: *const SkBitmap) -> bool;
}
extern "C" {
    pub fn C_SkBitmap_tryAllocN32Pixels(
        self_: *mut SkBitmap,
        width: ::std::os::raw::c_int,
        height: ::std::os::raw::c_int,
        isOpaque: bool,
    ) -> bool;
}
extern "C" {
    pub fn C_SkBitmap_tryAllocPixels(self_: *mut SkBitmap) -> bool;
}
extern "C" {
    pub fn C_SkBitmap_setPixelRef(
        self_: *mut SkBitmap,
        pixelRef: *mut SkPixelRef,
        dx: ::std::os::raw::c_int,
        dy: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn C_SkBitmap_readyToDraw(self_: *const SkBitmap) -> bool;
}
extern "C" {
    pub fn C_SkBitmap_eraseARGB(self_: *const SkBitmap, a: U8CPU, r: U8CPU, g: U8CPU, b: U8CPU);
}
extern "C" {
    pub fn C_SkBitmap_getAlphaf(
        self_: *const SkBitmap,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
    ) -> f32;
}
extern "C" {
    pub fn C_SkBitmap_extractAlpha(
        self_: *const SkBitmap,
        dst: *mut SkBitmap,
        paint: *const SkPaint,
        offset: *mut SkIPoint,
    ) -> bool;
}
extern "C" {
    pub fn C_SkBitmap_makeShader(
        self_: *const SkBitmap,
        tmx: SkTileMode,
        tmy: SkTileMode,
        localMatrix: *const SkMatrix,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkPicture_MakeFromData(data: *const SkData) -> *mut SkPicture;
}
extern "C" {
    pub fn C_SkPicture_MakeFromData2(
        data: *const ::std::os::raw::c_void,
        size: usize,
    ) -> *mut SkPicture;
}
extern "C" {
    pub fn C_SkPicture_serialize(self_: *const SkPicture) -> *mut SkData;
}
extern "C" {
    pub fn C_SkPicture_MakePlaceholder(cull: *const SkRect) -> *mut SkPicture;
}
extern "C" {
    pub fn C_SkPicture_playback(self_: *const SkPicture, canvas: *mut SkCanvas);
}
extern "C" {
    pub fn C_SkPicture_cullRect(self_: *const SkPicture) -> SkRect;
}
extern "C" {
    pub fn C_SkPicture_uniqueID(self_: *const SkPicture) -> u32;
}
extern "C" {
    pub fn C_SkPicture_approximateOpCount(self_: *const SkPicture) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn C_SkPicture_approximateBytesUsed(self_: *const SkPicture, out: *mut usize);
}
extern "C" {
    pub fn C_SkPicture_makeShader(
        self_: *const SkPicture,
        tmx: SkTileMode,
        tmy: SkTileMode,
        localMatrix: *const SkMatrix,
        tileRect: *const SkRect,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkRRect_Construct(uninitialized: *mut SkRRect);
}
extern "C" {
    pub fn C_SkRRect_getType(self_: *const SkRRect) -> SkRRect_Type;
}
extern "C" {
    pub fn C_SkRRect_setRect(self_: *mut SkRRect, rect: *const SkRect);
}
extern "C" {
    pub fn C_SkRRect_setOval(self_: *mut SkRRect, oval: *const SkRect);
}
extern "C" {
    pub fn C_SkRRect_Equals(lhs: *const SkRRect, rhs: *const SkRRect) -> bool;
}
extern "C" {
    pub fn C_GrBackendRenderTarget_Construct(uninitialized: *mut GrBackendRenderTarget);
}
extern "C" {
    pub fn C_GrBackendRenderTarget_destruct(self_: *mut GrBackendRenderTarget);
}
extern "C" {
    pub fn C_GrBackendTexture_Construct(uninitialized: *mut GrBackendTexture);
}
extern "C" {
    pub fn C_GrBackendTexture_destruct(self_: *const GrBackendTexture);
}
extern "C" {
    pub fn C_SkRegion_destruct(region: *mut SkRegion);
}
extern "C" {
    pub fn C_SkRegion_Equals(lhs: *const SkRegion, rhs: *const SkRegion) -> bool;
}
extern "C" {
    pub fn C_SkRegion_set(self_: *mut SkRegion, region: *const SkRegion) -> bool;
}
extern "C" {
    pub fn C_SkRegion_quickContains(
        self_: *const SkRegion,
        left: i32,
        top: i32,
        right: i32,
        bottom: i32,
    ) -> bool;
}
extern "C" {
    pub fn C_SkRegion_Iterator_Construct(uninitialized: *mut SkRegion_Iterator);
}
extern "C" {
    pub fn C_SkRegion_Iterator_destruct(self_: *mut SkRegion_Iterator);
}
extern "C" {
    pub fn C_SkRegion_Iterator_rgn(self_: *const SkRegion_Iterator) -> *const SkRegion;
}
extern "C" {
    pub fn C_SkRegion_Cliperator_destruct(self_: *mut SkRegion_Cliperator);
}
extern "C" {
    pub fn C_SkRegion_Spanerator_destruct(self_: *mut SkRegion_Spanerator);
}
extern "C" {
    pub fn C_SkFontStyle_Construct(uninitialized: *mut SkFontStyle);
}
extern "C" {
    pub fn C_SkFontStyle_Construct2(
        uninitialized: *mut SkFontStyle,
        weight: ::std::os::raw::c_int,
        width: ::std::os::raw::c_int,
        slant: SkFontStyle_Slant,
    );
}
extern "C" {
    pub fn C_SkFontStyle_Equals(lhs: *const SkFontStyle, rhs: *const SkFontStyle) -> bool;
}
extern "C" {
    pub fn C_SkFontStyle_weight(self_: *const SkFontStyle) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn C_SkFontStyle_width(self_: *const SkFontStyle) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn C_SkFontStyle_slant(self_: *const SkFontStyle) -> SkFontStyle_Slant;
}
extern "C" {
    pub fn C_SkTextBlob_ref(self_: *const SkTextBlob);
}
extern "C" {
    pub fn C_SkTextBlob_unref(self_: *const SkTextBlob);
}
extern "C" {
    pub fn C_SkTextBlob_unique(self_: *const SkTextBlob) -> bool;
}
extern "C" {
    pub fn C_SkTextBlob_MakeFromText(
        text: *const ::std::os::raw::c_void,
        byteLength: usize,
        font: *const SkFont,
        encoding: SkTextEncoding,
    ) -> *mut SkTextBlob;
}
extern "C" {
    pub fn C_SkTextBlob_MakeFromPosTextH(
        text: *const ::std::os::raw::c_void,
        byteLength: usize,
        xpos: *const SkScalar,
        constY: SkScalar,
        font: *const SkFont,
        encoding: SkTextEncoding,
    ) -> *mut SkTextBlob;
}
extern "C" {
    pub fn C_SkTextBlob_MakeFromPosText(
        text: *const ::std::os::raw::c_void,
        byteLength: usize,
        pos: *const SkPoint,
        font: *const SkFont,
        encoding: SkTextEncoding,
    ) -> *mut SkTextBlob;
}
extern "C" {
    pub fn C_SkTextBlob_MakeFromRSXform(
        text: *const ::std::os::raw::c_void,
        byteLength: usize,
        xform: *const SkRSXform,
        font: *const SkFont,
        encoding: SkTextEncoding,
    ) -> *mut SkTextBlob;
}
extern "C" {
    pub fn C_SkTextBlobBuilder_destruct(self_: *mut SkTextBlobBuilder);
}
extern "C" {
    pub fn C_SkTextBlobBuilder_make(self_: *mut SkTextBlobBuilder) -> *mut SkTextBlob;
}
extern "C" {
    pub fn C_SkTypeface_isBold(self_: *const SkTypeface) -> bool;
}
extern "C" {
    pub fn C_SkTypeface_isItalic(self_: *const SkTypeface) -> bool;
}
extern "C" {
    pub fn C_SkTypeface_MakeDefault() -> *mut SkTypeface;
}
extern "C" {
    pub fn C_SkTypeface_MakeFromName(
        familyName: *const ::std::os::raw::c_char,
        fontStyle: SkFontStyle,
    ) -> *mut SkTypeface;
}
extern "C" {
    pub fn C_SkTypeface_MakeFromData(
        data: *mut SkData,
        index: ::std::os::raw::c_int,
    ) -> *mut SkTypeface;
}
extern "C" {
    pub fn C_SkTypeface_makeClone(
        self_: *const SkTypeface,
        arguments: *const SkFontArguments,
    ) -> *mut SkTypeface;
}
extern "C" {
    pub fn C_SkTypeface_serialize(
        self_: *const SkTypeface,
        behavior: SkTypeface_SerializeBehavior,
    ) -> *mut SkData;
}
extern "C" {
    pub fn C_SkTypeface_MakeDeserialize(stream: *mut SkStream) -> *mut SkTypeface;
}
extern "C" {
    pub fn C_SkTypeface_copyTableData(self_: *const SkTypeface, tag: SkFontTableTag)
        -> *mut SkData;
}
extern "C" {
    pub fn C_SkTypeface_LocalizedStrings_unref(self_: *mut SkTypeface_LocalizedStrings);
}
extern "C" {
    pub fn C_SkTypeface_LocalizedStrings_next(
        self_: *mut SkTypeface_LocalizedStrings,
        string: *mut SkString,
        language: *mut SkString,
    ) -> bool;
}
extern "C" {
    pub fn C_SkYUVAIndex_AreValidIndices(
        yuvaIndices: *const SkYUVAIndex,
        numPlanes: *mut ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    pub fn C_SkYUVASizeInfo_equals(l: *const SkYUVASizeInfo, r: *const SkYUVASizeInfo) -> bool;
}
extern "C" {
    pub fn C_SkYUVASizeInfo_computeTotalBytes(self_: *const SkYUVASizeInfo) -> usize;
}
extern "C" {
    pub fn C_SkFlattenable_getTypeName(
        self_: *const SkFlattenable,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn C_SkFlattenable_serialize(self_: *const SkFlattenable) -> *mut SkData;
}
extern "C" {
    pub fn C_SkFont_ConstructFromTypeface(uninitialized: *mut SkFont, typeface: *mut SkTypeface);
}
extern "C" {
    pub fn C_SkFont_ConstructFromTypefaceWithSize(
        uninitialized: *mut SkFont,
        typeface: *mut SkTypeface,
        size: SkScalar,
    );
}
extern "C" {
    pub fn C_SkFont_ConstructFromTypefaceWithSizeScaleAndSkew(
        uninitialized: *mut SkFont,
        typeface: *mut SkTypeface,
        size: SkScalar,
        scaleX: SkScalar,
        skewX: SkScalar,
    );
}
extern "C" {
    pub fn C_SkFont_Equals(self_: *const SkFont, other: *const SkFont) -> bool;
}
extern "C" {
    pub fn C_SkFont_getEdging(self_: *const SkFont) -> SkFont_Edging;
}
extern "C" {
    pub fn C_SkFont_getHinting(self_: *const SkFont) -> SkFontHinting;
}
extern "C" {
    pub fn C_SkFont_makeWithSize(self_: *const SkFont, size: SkScalar, result: *mut SkFont);
}
extern "C" {
    pub fn C_SkFont_getTypeface(self_: *mut SkFont) -> *mut SkTypeface;
}
extern "C" {
    pub fn C_SkFont_setTypeface(self_: *mut SkFont, tf: *mut SkTypeface);
}
extern "C" {
    pub fn C_SkFont_destruct(self_: *mut SkFont);
}
extern "C" {
    pub fn C_SkFontArguments_construct(uninitialized: *mut SkFontArguments);
}
extern "C" {
    pub fn C_SkFontArguments_destruct(self_: *mut SkFontArguments);
}
extern "C" {
    pub fn C_SkFontArguments_setCollectionIndex(
        self_: *mut SkFontArguments,
        collectionIndex: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn C_SkFontArguments_setVariationDesignPosition(
        self_: *mut SkFontArguments,
        position: SkFontArguments_VariationPosition,
    );
}
extern "C" {
    pub fn C_SkFontArguments_getVariationDesignPosition(
        self_: *const SkFontArguments,
    ) -> SkFontArguments_VariationPosition;
}
extern "C" {
    pub fn C_SkFontStyleSet_count(self_: *mut SkFontStyleSet) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn C_SkFontStyleSet_getStyle(
        self_: *mut SkFontStyleSet,
        index: ::std::os::raw::c_int,
        fontStyle: *mut SkFontStyle,
        style: *mut SkString,
    );
}
extern "C" {
    pub fn C_SkFontStyleSet_createTypeface(
        self_: *mut SkFontStyleSet,
        index: ::std::os::raw::c_int,
    ) -> *mut SkTypeface;
}
extern "C" {
    pub fn C_SkFontStyleSet_matchStyle(
        self_: *mut SkFontStyleSet,
        pattern: *const SkFontStyle,
    ) -> *mut SkTypeface;
}
extern "C" {
    pub fn C_SkFontMgr_makeFromStream(
        self_: *const SkFontMgr,
        stream: *mut SkStreamAsset,
        ttcIndex: ::std::os::raw::c_int,
    ) -> *mut SkTypeface;
}
extern "C" {
    pub fn C_SkFontMgr_RefDefault() -> *mut SkFontMgr;
}
extern "C" {
    pub fn C_SkFontParameters_Variation_Axis_isHidden(
        self_: *const SkFontParameters_Variation_Axis,
    ) -> bool;
}
extern "C" {
    pub fn C_SkFontParameters_Variation_Axis_setHidden(
        self_: *mut SkFontParameters_Variation_Axis,
        hidden: bool,
    );
}
extern "C" {
    pub fn C_SkVertices_ref(self_: *const SkVertices);
}
extern "C" {
    pub fn C_SkVertices_unref(self_: *const SkVertices);
}
extern "C" {
    pub fn C_SkVertices_unique(self_: *const SkVertices) -> bool;
}
extern "C" {
    pub fn C_SkVertices_MakeCopy(
        mode: SkVertices_VertexMode,
        vertexCount: ::std::os::raw::c_int,
        positions: *const SkPoint,
        texs: *const SkPoint,
        colors: *const SkColor,
        boneIndices: *const SkVertices_BoneIndices,
        boneWeights: *const SkVertices_BoneWeights,
        indexCount: ::std::os::raw::c_int,
        indices: *const u16,
        isVolatile: bool,
    ) -> *mut SkVertices;
}
extern "C" {
    pub fn C_SkVertices_applyBones(
        self_: *const SkVertices,
        bones: *const SkVertices_Bone,
        boneCount: ::std::os::raw::c_int,
    ) -> *mut SkVertices;
}
extern "C" {
    pub fn C_SkVertices_Decode(
        buffer: *const ::std::os::raw::c_void,
        length: usize,
    ) -> *mut SkVertices;
}
extern "C" {
    pub fn C_SkVertices_encode(self_: *const SkVertices) -> *mut SkData;
}
extern "C" {
    pub fn C_SkVertices_Bone_mapRect(self_: *const SkVertices_Bone, rect: *const SkRect) -> SkRect;
}
extern "C" {
    pub fn C_SkVertices_Builder_destruct(builder: *mut SkVertices_Builder);
}
extern "C" {
    pub fn C_SkVertices_Builder_detach(builder: *mut SkVertices_Builder) -> *mut SkVertices;
}
extern "C" {
    pub fn C_SkPictureRecorder_destruct(self_: *mut SkPictureRecorder);
}
extern "C" {
    pub fn C_SkPictureRecorder_finishRecordingAsPicture(
        self_: *mut SkPictureRecorder,
        cullRect: *const SkRect,
    ) -> *mut SkPicture;
}
extern "C" {
    pub fn C_SkPictureRecorder_finishRecordingAsDrawable(
        self_: *mut SkPictureRecorder,
    ) -> *mut SkDrawable;
}
extern "C" {
    pub fn C_SkPixelRef_width(self_: *const SkPixelRef) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn C_SkPixelRef_height(self_: *const SkPixelRef) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn C_SkPixelRef_pixels(self_: *const SkPixelRef) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn C_SkPixelRef_rowBytes(self_: *const SkPixelRef) -> usize;
}
extern "C" {
    pub fn C_SkPixelRef_isImmutable(self_: *const SkPixelRef) -> bool;
}
extern "C" {
    pub fn C_SkPixelRef_notifyAddedToCache(self_: *mut SkPixelRef);
}
extern "C" {
    pub fn C_SkPoint_isFinite(self_: *const SkPoint) -> bool;
}
extern "C" {
    pub fn C_SkIRect_isEmpty(self_: *const SkIRect) -> bool;
}
extern "C" {
    pub fn C_SkIRect_contains(self_: *const SkIRect, rect: *const SkRect) -> bool;
}
extern "C" {
    pub fn C_SkRect_round(self_: *const SkRect, dst: *mut SkIRect);
}
extern "C" {
    pub fn C_SkRect_roundIn(self_: *const SkRect, dst: *mut SkIRect);
}
extern "C" {
    pub fn C_SkRect_roundOut(self_: *const SkRect, dst: *mut SkIRect);
}
extern "C" {
    pub fn C_SkRefCntBase_ref(self_: *const SkRefCntBase);
}
extern "C" {
    pub fn C_SkRefCntBase_unref(self_: *const SkRefCntBase);
}
extern "C" {
    pub fn C_SkRefCntBase_unique(self_: *const SkRefCntBase) -> bool;
}
extern "C" {
    pub fn C_SkColorFilter_makeComposed(
        self_: *const SkColorFilter,
        inner: *mut SkColorFilter,
    ) -> *mut SkColorFilter;
}
extern "C" {
    pub fn C_SkColorFilter_asAColorMode(
        self_: *const SkColorFilter,
        color: *mut SkColor,
        mode: *mut SkBlendMode,
    ) -> bool;
}
extern "C" {
    pub fn C_SkColorFilter_asAColorMatrix(
        self_: *const SkColorFilter,
        matrix: *mut SkScalar,
    ) -> bool;
}
extern "C" {
    pub fn C_SkColorFilter_getFlags(self_: *const SkColorFilter) -> u32;
}
extern "C" {
    pub fn C_SkColorFilter_Deserialize(
        data: *const ::std::os::raw::c_void,
        size: usize,
    ) -> *mut SkColorFilter;
}
extern "C" {
    pub fn C_SkColorFilters_Compose(
        outer: *mut SkColorFilter,
        inner: *mut SkColorFilter,
    ) -> *mut SkColorFilter;
}
extern "C" {
    pub fn C_SkColorFilters_Blend(c: SkColor, blendMode: SkBlendMode) -> *mut SkColorFilter;
}
extern "C" {
    pub fn C_SkColorFilters_Matrix(colorMatrix: *const SkColorMatrix) -> *mut SkColorFilter;
}
extern "C" {
    pub fn C_SkColorFilters_MatrixRowMajor(array: *const SkScalar) -> *mut SkColorFilter;
}
extern "C" {
    pub fn C_SkColorFilters_LinearToSRGBGamma() -> *mut SkColorFilter;
}
extern "C" {
    pub fn C_SkColorFilters_SRGBToLinearGamma() -> *mut SkColorFilter;
}
extern "C" {
    pub fn C_SkColorFilters_Lerp(
        t: f32,
        dst: *mut SkColorFilter,
        src: *mut SkColorFilter,
    ) -> *mut SkColorFilter;
}
extern "C" {
    pub fn C_SkContourMeasureIter_destruct(self_: *mut SkContourMeasureIter);
}
extern "C" {
    pub fn C_SkContourMeasureIter_next(self_: *mut SkContourMeasureIter) -> *mut SkContourMeasure;
}
extern "C" {
    pub fn C_SkDataTable_count(self_: *const SkDataTable) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn C_SkDataTable_MakeEmpty() -> *mut SkDataTable;
}
extern "C" {
    pub fn C_SkDataTable_MakeCopyArrays(
        ptrs: *const *const ::std::os::raw::c_void,
        sizes: *const usize,
        count: ::std::os::raw::c_int,
    ) -> *mut SkDataTable;
}
extern "C" {
    pub fn C_SkDataTable_MakeCopyArray(
        array: *const ::std::os::raw::c_void,
        elemSize: usize,
        count: ::std::os::raw::c_int,
    ) -> *mut SkDataTable;
}
extern "C" {
    pub fn C_SkDeferredDisplayListRecorder_destruct(self_: *mut SkDeferredDisplayListRecorder);
}
extern "C" {
    pub fn C_SkDeferredDisplayListRecorder_detach(
        self_: *mut SkDeferredDisplayListRecorder,
    ) -> *mut SkDeferredDisplayList;
}
extern "C" {
    pub fn C_SkDeferredDisplayList_delete(self_: *mut SkDeferredDisplayList);
}
extern "C" {
    pub fn C_SkDrawLooper_asABlurShadow(
        self_: *const SkDrawLooper,
        br: *mut SkDrawLooper_BlurShadowRec,
    ) -> bool;
}
extern "C" {
    pub fn C_SkDrawLooper_Deserialize(
        data: *const ::std::os::raw::c_void,
        length: usize,
    ) -> *mut SkDrawLooper;
}
extern "C" {
    pub fn C_SkDrawable_snapGpuDrawHandler(
        self_: *mut SkDrawable,
        backendApi: GrBackendApi,
        matrix: *const SkMatrix,
        clipBounds: *const SkIRect,
        bufferInfo: *const SkImageInfo,
    ) -> *mut SkDrawable_GpuDrawHandler;
}
extern "C" {
    pub fn C_SkDrawable_Deserialize(
        data: *const ::std::os::raw::c_void,
        length: usize,
    ) -> *mut SkDrawable;
}
extern "C" {
    pub fn C_SkDrawable_GpuDrawHandler_delete(self_: *mut SkDrawable_GpuDrawHandler);
}
extern "C" {
    pub fn C_SkDrawable_GpuDrawHandler_draw(
        self_: *mut SkDrawable_GpuDrawHandler,
        info: *const GrBackendDrawableInfo,
    );
}
extern "C" {
    pub fn C_SkImageFilter_computeFastBounds(
        self_: *const SkImageFilter,
        bounds: *const SkRect,
    ) -> SkRect;
}
extern "C" {
    pub fn C_SkImageFilter_makeWithLocalMatrix(
        self_: *const SkImageFilter,
        matrix: *const SkMatrix,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkImageFilter_MakeMatrixFilter(
        matrix: *const SkMatrix,
        quality: SkFilterQuality,
        input: *mut SkImageFilter,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkImageFilter_Deserialize(
        data: *const ::std::os::raw::c_void,
        length: usize,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkImageFilter_isColorFilterNode(
        self_: *const SkImageFilter,
        filterPtr: *mut *mut SkColorFilter,
    ) -> bool;
}
extern "C" {
    pub fn C_SkImageFilter_countInputs(self_: *const SkImageFilter) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn C_SkImageFilter_getInput(
        self_: *const SkImageFilter,
        i: ::std::os::raw::c_int,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkImageGenerator_delete(self_: *mut SkImageGenerator);
}
extern "C" {
    pub fn C_SkImageGenerator_refEncodedData(self_: *mut SkImageGenerator) -> *mut SkData;
}
extern "C" {
    pub fn C_SkImageGenerator_isValid(
        self_: *const SkImageGenerator,
        context: *mut GrContext,
    ) -> bool;
}
extern "C" {
    pub fn C_SkImageGenerator_MakeFromEncoded(data: *mut SkData) -> *mut SkImageGenerator;
}
extern "C" {
    pub fn C_SkImageGenerator_MakeFromPicture(
        size: *const SkISize,
        picture: *mut SkPicture,
        matrix: *const SkMatrix,
        paint: *const SkPaint,
        bd: SkImage_BitDepth,
        cs: *mut SkColorSpace,
    ) -> *mut SkImageGenerator;
}
extern "C" {
    pub fn C_SkString_destruct(self_: *mut SkString);
}
extern "C" {
    pub fn C_SkString_c_str_size(
        self_: *const SkString,
        size: *mut usize,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn C_SkStrokeRec_destruct(self_: *mut SkStrokeRec);
}
extern "C" {
    pub fn C_SkStrokeRec_copy(self_: *const SkStrokeRec, other: *mut SkStrokeRec);
}
extern "C" {
    pub fn C_SkStrokeRec_getCap(self_: *const SkStrokeRec) -> SkPaint_Cap;
}
extern "C" {
    pub fn C_SkStrokeRec_getJoin(self_: *const SkStrokeRec) -> SkPaint_Join;
}
extern "C" {
    pub fn C_SkStrokeRec_hasEqualEffect(
        self_: *const SkStrokeRec,
        other: *const SkStrokeRec,
    ) -> bool;
}
extern "C" {
    pub fn C_SkPathEffect_MakeSum(
        first: *mut SkPathEffect,
        second: *mut SkPathEffect,
    ) -> *mut SkPathEffect;
}
extern "C" {
    pub fn C_SkPathEffect_MakeCompose(
        outer: *mut SkPathEffect,
        inner: *mut SkPathEffect,
    ) -> *mut SkPathEffect;
}
extern "C" {
    pub fn C_SkPathEffect_PointData_Construct(unitialized: *mut SkPathEffect_PointData);
}
extern "C" {
    pub fn C_SkPathEffect_PointData_deletePoints(self_: *mut SkPathEffect_PointData);
}
extern "C" {
    pub fn C_SkPathEffect_DashInfo_Construct(uninitialized: *mut SkPathEffect_DashInfo);
}
extern "C" {
    pub fn C_SkPathEffect_Deserialize(
        data: *const ::std::os::raw::c_void,
        length: usize,
    ) -> *mut SkPathEffect;
}
extern "C" {
    pub fn C_SkPixmap_destruct(self_: *mut SkPixmap);
}
extern "C" {
    pub fn C_SkPixmap_setColorSpace(self_: *mut SkPixmap, colorSpace: *mut SkColorSpace);
}
extern "C" {
    pub fn C_SkPixmap_dimensions(self_: *const SkPixmap) -> SkISize;
}
extern "C" {
    pub fn C_SkMaskFilter_MakeBlur(
        style: SkBlurStyle,
        sigma: SkScalar,
        respectCTM: bool,
    ) -> *mut SkMaskFilter;
}
extern "C" {
    pub fn C_SkMaskFilter_Compose(
        outer: *mut SkMaskFilter,
        inner: *mut SkMaskFilter,
    ) -> *mut SkMaskFilter;
}
extern "C" {
    pub fn C_SkMaskFilter_Combine(
        filterA: *mut SkMaskFilter,
        filterB: *mut SkMaskFilter,
        coverageMode: SkCoverageMode,
    ) -> *mut SkMaskFilter;
}
extern "C" {
    pub fn C_SkMaskFilter_makeWithMatrix(
        self_: *const SkMaskFilter,
        matrix: *const SkMatrix,
    ) -> *mut SkMaskFilter;
}
extern "C" {
    pub fn C_SkMaskFilter_Deserialize(
        data: *const ::std::os::raw::c_void,
        length: usize,
    ) -> *mut SkMaskFilter;
}
extern "C" {
    pub fn C_SkSize_toRound(size: *const SkSize) -> SkISize;
}
extern "C" {
    pub fn C_SkSize_toCeil(size: *const SkSize) -> SkISize;
}
extern "C" {
    pub fn C_SkSize_toFloor(size: *const SkSize) -> SkISize;
}
extern "C" {
    pub fn C_SkShader_isOpaque(self_: *const SkShader) -> bool;
}
extern "C" {
    pub fn C_SkShader_isAImage(self_: *const SkShader) -> bool;
}
extern "C" {
    pub fn C_SkShader_asAGradient(
        self_: *const SkShader,
        info: *mut SkShader_GradientInfo,
    ) -> SkShader_GradientType;
}
extern "C" {
    pub fn C_SkShader_makeWithLocalMatrix(
        self_: *const SkShader,
        matrix: *const SkMatrix,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkShader_makeWithColorFilter(
        self_: *const SkShader,
        colorFilter: *mut SkColorFilter,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkShaders_Empty() -> *mut SkShader;
}
extern "C" {
    pub fn C_SkShaders_Color(color: SkColor) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkShaders_Color2(
        color: *const SkColor4f,
        colorSpace: *mut SkColorSpace,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkShaders_Blend(
        mode: SkBlendMode,
        dst: *mut SkShader,
        src: *mut SkShader,
        localMatrix: *const SkMatrix,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkShaders_Lerp(
        t: f32,
        dst: *mut SkShader,
        src: *mut SkShader,
        localMatrix: *const SkMatrix,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkShaders_Lerp2(
        red: *mut SkShader,
        dst: *mut SkShader,
        src: *mut SkShader,
        localMatrix: *const SkMatrix,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkShader_Deserialize(
        data: *const ::std::os::raw::c_void,
        length: usize,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkStream_delete(stream: *mut SkStream);
}
extern "C" {
    pub fn C_SkWStream_destruct(self_: *mut SkWStream);
}
extern "C" {
    pub fn C_SkWStream_write(
        self_: *mut SkWStream,
        buffer: *const ::std::os::raw::c_void,
        size: usize,
    ) -> bool;
}
extern "C" {
    pub fn C_SkMemoryStream_MakeDirect(
        data: *const ::std::os::raw::c_void,
        length: usize,
    ) -> *mut SkMemoryStream;
}
extern "C" {
    pub fn C_SkDynamicMemoryWStream_Construct(uninitialized: *mut SkDynamicMemoryWStream);
}
extern "C" {
    pub fn C_SkDynamicMemoryWStream_detachAsData(self_: *mut SkDynamicMemoryWStream)
        -> *mut SkData;
}
extern "C" {
    pub fn C_SkDynamicMemoryWStream_detachAsStream(
        self_: *mut SkDynamicMemoryWStream,
    ) -> *mut SkStreamAsset;
}
extern "C" {
    pub fn C_SkGradientShader_MakeLinear(
        pts: *const SkPoint,
        colors: *const SkColor,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkGradientShader_MakeLinear2(
        pts: *const SkPoint,
        colors: *const SkColor4f,
        colorSpace: *mut SkColorSpace,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkGradientShader_MakeRadial(
        center: *const SkPoint,
        radius: SkScalar,
        colors: *const SkColor,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkGradientShader_MakeRadial2(
        center: *const SkPoint,
        radius: SkScalar,
        colors: *const SkColor4f,
        colorSpace: *mut SkColorSpace,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkGradientShader_MakeTwoPointConical(
        start: *const SkPoint,
        startRadius: SkScalar,
        end: *const SkPoint,
        endRadius: SkScalar,
        colors: *const SkColor,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkGradientShader_MakeTwoPointConical2(
        start: *const SkPoint,
        startRadius: SkScalar,
        end: *const SkPoint,
        endRadius: SkScalar,
        colors: *const SkColor4f,
        colorSpace: *mut SkColorSpace,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkGradientShader_MakeSweep(
        cx: SkScalar,
        cy: SkScalar,
        colors: *const SkColor,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        startAngle: SkScalar,
        endAngle: SkScalar,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkGradientShader_MakeSweep2(
        cx: SkScalar,
        cy: SkScalar,
        colors: *const SkColor4f,
        colorSpace: *mut SkColorSpace,
        pos: *const SkScalar,
        count: ::std::os::raw::c_int,
        mode: SkTileMode,
        startAngle: SkScalar,
        endAngle: SkScalar,
        flags: u32,
        localMatrix: *const SkMatrix,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkPerlinNoiseShader_MakeFractalNoise(
        baseFrequencyX: SkScalar,
        baseFrequencyY: SkScalar,
        numOctaves: ::std::os::raw::c_int,
        seed: SkScalar,
        tileSize: *const SkISize,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkPerlinNoiseShader_MakeTurbulence(
        baseFrequencyX: SkScalar,
        baseFrequencyY: SkScalar,
        numOctaves: ::std::os::raw::c_int,
        seed: SkScalar,
        tileSize: *const SkISize,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkPerlinNoiseShader_MakeImprovedNoise(
        baseFrequencyX: SkScalar,
        baseFrequencyY: SkScalar,
        numOctaves: ::std::os::raw::c_int,
        z: SkScalar,
    ) -> *mut SkShader;
}
extern "C" {
    pub fn C_SkPath1DPathEffect_Make(
        path: *const SkPath,
        advance: SkScalar,
        phase: SkScalar,
        style: SkPath1DPathEffect_Style,
    ) -> *mut SkPathEffect;
}
extern "C" {
    pub fn C_SkLine2DPathEffect_Make(width: SkScalar, matrix: *const SkMatrix)
        -> *mut SkPathEffect;
}
extern "C" {
    pub fn C_SkPath2DPathEffect_Make(
        matrix: *const SkMatrix,
        path: *const SkPath,
    ) -> *mut SkPathEffect;
}
extern "C" {
    pub fn C_SkAlphaThresholdFilter_Make(
        region: *const SkRegion,
        innerMin: SkScalar,
        outerMax: SkScalar,
        input: *mut SkImageFilter,
        cropRect: *const SkImageFilter_CropRect,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkArithmeticImageFilter_Make(
        k1: f32,
        k2: f32,
        k3: f32,
        k4: f32,
        enforcePMColor: bool,
        background: *mut SkImageFilter,
        foreground: *mut SkImageFilter,
        cropRect: *const SkImageFilter_CropRect,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkBlurDrawLooper_Make(
        color: SkColor,
        sigma: SkScalar,
        dx: SkScalar,
        dy: SkScalar,
    ) -> *mut SkDrawLooper;
}
extern "C" {
    pub fn C_SkBlurDrawLooper_Make2(
        color: SkColor4f,
        cs: *const SkColorSpace,
        sigma: SkScalar,
        dx: SkScalar,
        dy: SkScalar,
    ) -> *mut SkDrawLooper;
}
extern "C" {
    pub fn C_SkBlurImageFilter_Make(
        sigmaX: SkScalar,
        sigmaY: SkScalar,
        input: *mut SkImageFilter,
        cropRect: *const SkImageFilter_CropRect,
        tileMode: SkBlurImageFilter_TileMode,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkColorFilterImageFilter_Make(
        cf: *mut SkColorFilter,
        input: *mut SkImageFilter,
        cropRect: *const SkImageFilter_CropRect,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkColorMatrix_equals(lhs: *const SkColorMatrix, rhs: *const SkColorMatrix) -> bool;
}
extern "C" {
    pub fn C_SkColorMatrix_get20(self_: *const SkColorMatrix, m: *mut f32) -> *mut f32;
}
extern "C" {
    pub fn C_SkColorMatrix_set20(self_: *mut SkColorMatrix, m: *const f32);
}
extern "C" {
    pub fn C_SkComposeImageFilter_Make(
        outer: *mut SkImageFilter,
        inner: *mut SkImageFilter,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkCornerPathEffect_Make(radius: SkScalar) -> *mut SkPathEffect;
}
extern "C" {
    pub fn C_SkDashPathEffect_Make(
        intervals: *const SkScalar,
        count: ::std::os::raw::c_int,
        phase: SkScalar,
    ) -> *mut SkPathEffect;
}
extern "C" {
    pub fn C_SkDiscretePathEffect_Make(
        segLength: SkScalar,
        dev: SkScalar,
        seedAssist: u32,
    ) -> *mut SkPathEffect;
}
extern "C" {
    pub fn C_SkDisplacementMapEffect_Make(
        xChannelSelector: SkDisplacementMapEffect_ChannelSelectorType,
        yChannelSelector: SkDisplacementMapEffect_ChannelSelectorType,
        scale: SkScalar,
        displacement: *mut SkImageFilter,
        color: *mut SkImageFilter,
        cropRect: *const SkImageFilter_CropRect,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkDropShadowImageFilter_Make(
        dx: SkScalar,
        dy: SkScalar,
        sigmaX: SkScalar,
        sigmaY: SkScalar,
        color: SkColor,
        shadowMode: SkDropShadowImageFilter_ShadowMode,
        input: *mut SkImageFilter,
        cropRect: *const SkImageFilter_CropRect,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkImageSource_Make(image: *mut SkImage) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkImageSource_Make2(
        image: *mut SkImage,
        srcRect: *const SkRect,
        dstRect: *const SkRect,
        filterQuality: SkFilterQuality,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkLayerDrawLooper_Builder_destruct(self_: *mut SkLayerDrawLooper_Builder);
}
extern "C" {
    pub fn C_SkLayerDrawLooper_Builder_detach(
        self_: *mut SkLayerDrawLooper_Builder,
    ) -> *mut SkDrawLooper;
}
extern "C" {
    pub fn C_SkLightingImageFilter_MakeDistantLitDiffuse(
        direction: *const SkPoint3,
        lightColor: SkColor,
        surfaceScale: SkScalar,
        kd: SkScalar,
        input: *mut SkImageFilter,
        cropRect: *const SkImageFilter_CropRect,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkLightingImageFilter_MakePointLitDiffuse(
        location: *const SkPoint3,
        lightColor: SkColor,
        surfaceScale: SkScalar,
        kd: SkScalar,
        input: *mut SkImageFilter,
        cropRect: *const SkImageFilter_CropRect,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkLightingImageFilter_MakeSpotLitDiffuse(
        location: *const SkPoint3,
        target: *const SkPoint3,
        specularExponent: SkScalar,
        cutoffAngle: SkScalar,
        lightColor: SkColor,
        surfaceScale: SkScalar,
        kd: SkScalar,
        input: *mut SkImageFilter,
        cropRect: *const SkImageFilter_CropRect,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkLightingImageFilter_MakeDistantLitSpecular(
        direction: *const SkPoint3,
        lightColor: SkColor,
        surfaceScale: SkScalar,
        ks: SkScalar,
        shininess: SkScalar,
        input: *mut SkImageFilter,
        cropRect: *const SkImageFilter_CropRect,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkLightingImageFilter_MakePointLitSpecular(
        location: *const SkPoint3,
        lightColor: SkColor,
        surfaceScale: SkScalar,
        ks: SkScalar,
        shininess: SkScalar,
        input: *mut SkImageFilter,
        cropRect: *const SkImageFilter_CropRect,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkLightingImageFilter_MakeSpotLitSpecular(
        location: *const SkPoint3,
        target: *const SkPoint3,
        specularExponent: SkScalar,
        cutoffAngle: SkScalar,
        lightColor: SkColor,
        surfaceScale: SkScalar,
        ks: SkScalar,
        shininess: SkScalar,
        input: *mut SkImageFilter,
        cropRect: *const SkImageFilter_CropRect,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkMagnifierImageFilter_Make(
        srcRect: *const SkRect,
        inset: SkScalar,
        input: *mut SkImageFilter,
        cropRect: *const SkImageFilter_CropRect,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkMatrixConvolutionImageFilter_Make(
        kernelSize: *const SkISize,
        kernel: *const SkScalar,
        gain: SkScalar,
        bias: SkScalar,
        kernelOffset: *const SkIPoint,
        tileMode: SkMatrixConvolutionImageFilter_TileMode,
        convolveAlpha: bool,
        input: *mut SkImageFilter,
        cropRect: *const SkImageFilter_CropRect,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkMergeImageFilter_Make(
        filters: *const *mut SkImageFilter,
        count: ::std::os::raw::c_int,
        cropRect: *const SkImageFilter_CropRect,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkDilateImageFilter_Make(
        radiusX: ::std::os::raw::c_int,
        radiusY: ::std::os::raw::c_int,
        input: *mut SkImageFilter,
        cropRect: *const SkImageFilter_CropRect,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkErodeImageFilter_Make(
        radiusX: ::std::os::raw::c_int,
        radiusY: ::std::os::raw::c_int,
        input: *mut SkImageFilter,
        cropRect: *const SkImageFilter_CropRect,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkOffsetImageFilter_Make(
        dx: SkScalar,
        dy: SkScalar,
        input: *mut SkImageFilter,
        cropRect: *const SkImageFilter_CropRect,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkPaintImageFilter_Make(
        paint: *const SkPaint,
        cropRect: *const SkImageFilter_CropRect,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkPictureImageFilter_Make(
        picture: *mut SkPicture,
        cropRect: *const SkRect,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkTableColorFilter_Make(table: *const u8) -> *mut SkColorFilter;
}
extern "C" {
    pub fn C_SkTableColorFilter_MakeARGB(
        tableA: *const u8,
        tableR: *const u8,
        tableG: *const u8,
        tableB: *const u8,
    ) -> *mut SkColorFilter;
}
extern "C" {
    pub fn C_SkTileImageFilter_Make(
        src: *const SkRect,
        dst: *const SkRect,
        input: *mut SkImageFilter,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkXfermodeImageFilter_Make(
        mode: SkBlendMode,
        background: *mut SkImageFilter,
        foreground: *mut SkImageFilter,
        cropRect: *const SkImageFilter_CropRect,
    ) -> *mut SkImageFilter;
}
extern "C" {
    pub fn C_SkPDF_Metadata_Construct(uninitialized: *mut SkPDF_Metadata);
}
extern "C" {
    pub fn C_SkPDF_Metadata_destruct(self_: *mut SkPDF_Metadata);
}
extern "C" {
    pub fn C_SkPDF_MakeDocument(
        stream: *mut SkWStream,
        metadata: *const SkPDF_Metadata,
    ) -> *mut SkDocument;
}
extern "C" {
    pub fn C_GrBackendFormat_Construct(uninitialized: *mut GrBackendFormat);
}
extern "C" {
    pub fn C_GrBackendFormat_ConstructGL(
        uninitialized: *mut GrBackendFormat,
        format: GrGLenum,
        target: GrGLenum,
    );
}
extern "C" {
    pub fn C_GrBackendFormat_destruct(self_: *mut GrBackendFormat);
}
extern "C" {
    pub fn C_GrBackendFormat_Equals(
        lhs: *const GrBackendFormat,
        rhs: *const GrBackendFormat,
    ) -> bool;
}
extern "C" {
    pub fn C_GrGLTextureInfo_Equals(
        lhs: *const GrGLTextureInfo,
        rhs: *const GrGLTextureInfo,
    ) -> bool;
}
extern "C" {
    pub fn C_GrGLFramebufferInfo_Equals(
        lhs: *const GrGLFramebufferInfo,
        rhs: *const GrGLFramebufferInfo,
    ) -> bool;
}
extern "C" {
    pub fn C_GrGLInterface_MakeNativeInterface() -> *const GrGLInterface;
}
extern "C" {
    pub fn C_GrContext_MakeGL(interface: *mut GrGLInterface) -> *mut GrContext;
}
extern "C" {
    pub fn C_GrContext_colorTypeSupportedAsSurface(
        self_: *const GrContext,
        colorType: SkColorType,
    ) -> bool;
}
extern "C" {
    pub fn C_GrContext_abandoned(self_: *const GrContext) -> bool;
}
extern "C" {
    pub fn C_GrContext_flush(self_: *mut GrContext);
}
extern "C" {
    pub fn C_GrBackendDrawableInfo_Construct(uninitialized: *mut GrBackendDrawableInfo);
}
extern "C" {
    pub fn C_GrBackendDrawableInfo_Construct2(
        uninitialized: *mut GrBackendDrawableInfo,
        info: *const GrVkDrawableInfo,
    );
}
extern "C" {
    pub fn C_GrBackendDrawableInfo_destruct(self_: *mut GrBackendDrawableInfo);
}
extern "C" {
    pub fn C_GrBackendDrawableInfo_isValid(self_: *const GrBackendDrawableInfo) -> bool;
}
extern "C" {
    pub fn C_GrBackendDrawableInfo_backend(self_: *const GrBackendDrawableInfo) -> GrBackendApi;
}
extern "C" {
    pub fn C_SkOpBuilder_Construct(uninitialized: *mut SkOpBuilder);
}
extern "C" {
    pub fn C_SkOpBuilder_destruct(self_: *mut SkOpBuilder);
}
extern "C" {
    pub fn C_Sk3DView_new() -> *mut Sk3DView;
}
extern "C" {
    pub fn C_Sk3DView_delete(self_: *mut Sk3DView);
}
extern "C" {
    pub fn C_SkInterpolator_destruct(self_: *mut SkInterpolator);
}
extern "C" {
    pub fn C_SkInterpolator_setRepeatCount(self_: *mut SkInterpolator, repeatCount: SkScalar);
}
extern "C" {
    pub fn C_SkInterpolator_setReset(self_: *mut SkInterpolator, reset: bool);
}
extern "C" {
    pub fn C_SkInterpolator_setMirror(self_: *mut SkInterpolator, mirror: bool);
}
extern "C" {
    pub fn C_SkMakeNullCanvas() -> *mut SkCanvas;
}
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(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!(
        ::core::mem::size_of::<__va_list_tag>(),
        24usize,
        concat!("Size of: ", stringify!(__va_list_tag))
    );
    assert_eq!(
        ::core::mem::align_of::<__va_list_tag>(),
        8usize,
        concat!("Alignment of ", stringify!(__va_list_tag))
    );
    assert_eq!(
        unsafe { &(*(::core::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 { &(*(::core::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 {
            &(*(::core::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 { &(*(::core::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)
        )
    );
}
#[test]
fn __bindgen_test_layout_SkNVRefCnt_open0_SkColorSpace_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<SkNVRefCnt>(),
        4usize,
        concat!("Size of template specialization: ", stringify!(SkNVRefCnt))
    );
    assert_eq!(
        ::core::mem::align_of::<SkNVRefCnt>(),
        4usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(SkNVRefCnt)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_3() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_4() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_5() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_6() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_7() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_8() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorFilter_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorFilter_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPathEffect_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPathEffect_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkMaskFilter_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkMaskFilter_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImageFilter_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImageFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImageFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImageFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImageFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImageFilter_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImageFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImageFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImageFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImageFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPathEffect_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkMaskFilter_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorFilter_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkDrawLooper_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkDrawLooper>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkDrawLooper>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkDrawLooper>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkDrawLooper>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImageFilter_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImageFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImageFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImageFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImageFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkRasterHandleAllocator_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkCanvas_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkString_Rec_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkString_Rec>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkString_Rec>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkString_Rec>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkString_Rec>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkString_Rec_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkString_Rec>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkString_Rec>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkString_Rec>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkString_Rec>)
        )
    );
}
#[test]
fn __bindgen_test_layout_SkNVRefCnt_open0_SkData_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<SkNVRefCnt>(),
        4usize,
        concat!("Size of template specialization: ", stringify!(SkNVRefCnt))
    );
    assert_eq!(
        ::core::mem::align_of::<SkNVRefCnt>(),
        4usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(SkNVRefCnt)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_3() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_4() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_5() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_6() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_7() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_8() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_9() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_10() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_11() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_SkNVRefCnt_open0_SkVertices_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<SkNVRefCnt>(),
        4usize,
        concat!("Size of template specialization: ", stringify!(SkNVRefCnt))
    );
    assert_eq!(
        ::core::mem::align_of::<SkNVRefCnt>(),
        4usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(SkNVRefCnt)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkVertices_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkVertices>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkVertices>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkVertices>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkVertices>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkVertices_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkVertices>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkVertices>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkVertices>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkVertices>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkVertices_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkVertices>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkVertices>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkVertices>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkVertices>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkVertices_close0_instantiation_3() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkVertices>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkVertices>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkVertices>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkVertices>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkVertices_close0_instantiation_4() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkVertices>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkVertices>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkVertices>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkVertices>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_12() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkCanvas_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkBaseDevice_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkBaseDevice>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkBaseDevice>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkBaseDevice>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkBaseDevice>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkSurface_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkVertices_close0_instantiation_5() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkVertices>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkVertices>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkVertices>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkVertices>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkVertices_close0_instantiation_6() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkVertices>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkVertices>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkVertices>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkVertices>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkSurface_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct SkDrawIter {
    pub _address: u8,
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkRasterHandleAllocator_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkGlyphRunBuilder_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkFlattenable_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkFlattenable>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkFlattenable>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkFlattenable>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkFlattenable>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_13() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkFlattenable_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkFlattenable>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkFlattenable>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkFlattenable>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkFlattenable>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorFilter_close0_instantiation_3() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorFilter_close0_instantiation_4() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_SkNVRefCnt_open0_SkPathRef_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<SkNVRefCnt>(),
        4usize,
        concat!("Size of template specialization: ", stringify!(SkNVRefCnt))
    );
    assert_eq!(
        ::core::mem::align_of::<SkNVRefCnt>(),
        4usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(SkNVRefCnt)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPathRef_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPathRef>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPathRef>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPathRef>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPathRef>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPathRef_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPathRef>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPathRef>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPathRef>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPathRef>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPathRef_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPathRef>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPathRef>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPathRef>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPathRef>)
        )
    );
}
#[test]
fn __bindgen_test_layout_SkTDArray_open0_SkScalar_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<SkTDArray<SkScalar>>(),
        16usize,
        concat!(
            "Size of template specialization: ",
            stringify!(SkTDArray<SkScalar>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<SkTDArray<SkScalar>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(SkTDArray<SkScalar>)
        )
    );
}
#[test]
fn __bindgen_test_layout_SkTDArray_open0_ptr_GenIDChangeListener_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<SkTDArray<*mut SkPathRef_GenIDChangeListener>>(),
        16usize,
        concat!(
            "Size of template specialization: ",
            stringify!(SkTDArray<*mut SkPathRef_GenIDChangeListener>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<SkTDArray<*mut SkPathRef_GenIDChangeListener>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(SkTDArray<*mut SkPathRef_GenIDChangeListener>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_14() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPathRef_close0_instantiation_3() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPathRef>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPathRef>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPathRef>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPathRef>)
        )
    );
}
#[test]
fn __bindgen_test_layout_SkTDArray_open0_SkContourMeasure_Segment_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<SkTDArray<SkContourMeasure_Segment>>(),
        16usize,
        concat!(
            "Size of template specialization: ",
            stringify!(SkTDArray<SkContourMeasure_Segment>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<SkTDArray<SkContourMeasure_Segment>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(SkTDArray<SkContourMeasure_Segment>)
        )
    );
}
#[test]
fn __bindgen_test_layout_SkTDArray_open0_SkPoint_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<SkTDArray<SkPoint>>(),
        16usize,
        concat!(
            "Size of template specialization: ",
            stringify!(SkTDArray<SkPoint>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<SkTDArray<SkPoint>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(SkTDArray<SkPoint>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkContourMeasure_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkContourMeasure>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkContourMeasure>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkContourMeasure>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkContourMeasure>)
        )
    );
}
#[test]
fn __bindgen_test_layout_SkTDArray_open0_SkContourMeasure_Segment_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<SkTDArray<SkContourMeasure_Segment>>(),
        16usize,
        concat!(
            "Size of template specialization: ",
            stringify!(SkTDArray<SkContourMeasure_Segment>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<SkTDArray<SkContourMeasure_Segment>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(SkTDArray<SkContourMeasure_Segment>)
        )
    );
}
#[test]
fn __bindgen_test_layout_SkTDArray_open0_SkPoint_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<SkTDArray<SkPoint>>(),
        16usize,
        concat!(
            "Size of template specialization: ",
            stringify!(SkTDArray<SkPoint>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<SkTDArray<SkPoint>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(SkTDArray<SkPoint>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkDataTable_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkDataTable>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkDataTable>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkDataTable>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkDataTable>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkDataTable_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkDataTable>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkDataTable>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkDataTable>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkDataTable>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkDataTable_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkDataTable>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkDataTable>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkDataTable>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkDataTable>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkDataTable_close0_instantiation_3() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkDataTable>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkDataTable>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkDataTable>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkDataTable>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_chrono_duration_open0_int64_t_std_milli_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<std_chrono_duration<i64>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_chrono_duration<i64>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_chrono_duration<i64>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_chrono_duration<i64>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_9() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPixelRef_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPixelRef>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPixelRef>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPixelRef>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPixelRef>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation_3() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation_4() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPixelRef_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPixelRef>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPixelRef>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPixelRef>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPixelRef>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkStreamAsset_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_15() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkMemoryStream_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkMemoryStream_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_16() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkMemoryStream_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_17() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_18() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_19() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkStreamAsset_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation_5() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorFilter_close0_instantiation_5() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation_6() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_3() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_20() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_4() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_5() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_6() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkImageGenerator_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_7() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_21() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_8() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_22() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_9() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_10() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_10() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_23() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_11() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_12() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_11() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_13() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_12() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_14() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_13() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_15() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_14() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_16() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_15() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_17() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_16() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_18() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_17() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_19() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_18() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_20() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_19() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_21() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPicture_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPicture>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPicture>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPicture>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPicture>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_20() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_22() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_21() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation_7() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_24() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_25() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_26() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_23() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_24() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_25() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_26() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_27() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_28() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_29() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_22() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_30() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_23() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_31() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_SkNVRefCnt_open0_GrGLTextureParameters_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<SkNVRefCnt>(),
        4usize,
        concat!("Size of template specialization: ", stringify!(SkNVRefCnt))
    );
    assert_eq!(
        ::core::mem::align_of::<SkNVRefCnt>(),
        4usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(SkNVRefCnt)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPathEffect_close0_instantiation_3() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPathEffect_close0_instantiation_4() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPathEffect_close0_instantiation_5() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPathEffect_close0_instantiation_6() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPathEffect_close0_instantiation_7() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPathEffect_close0_instantiation_8() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_27() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrCaps_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrCaps>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrCaps>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrCaps>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrCaps>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrSkSLFPFactoryCache_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrSkSLFPFactoryCache>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrSkSLFPFactoryCache>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrSkSLFPFactoryCache>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrSkSLFPFactoryCache>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrCaps_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrCaps>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrCaps>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrCaps>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrCaps>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrSkSLFPFactoryCache_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrSkSLFPFactoryCache>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrSkSLFPFactoryCache>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrSkSLFPFactoryCache>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrSkSLFPFactoryCache>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrCaps_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrCaps>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrCaps>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrCaps>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrCaps>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrSkSLFPFactoryCache_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrSkSLFPFactoryCache>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrSkSLFPFactoryCache>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrSkSLFPFactoryCache>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrSkSLFPFactoryCache>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrOpMemoryPool_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrOpMemoryPool>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrOpMemoryPool>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrOpMemoryPool>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrOpMemoryPool>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_24() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_25() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_26() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_27() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrGLInterface_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrGLInterface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrGLInterface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrGLInterface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrGLInterface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrContext_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrContext>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrContext>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrContext>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrContext>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrGLInterface_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrGLInterface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrGLInterface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrGLInterface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrGLInterface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrContext_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrContext>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrContext>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrContext>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrContext>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrContext_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrContext>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrContext>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrContext>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrContext>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrContext_close0_instantiation_3() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrContext>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrContext>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrContext>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrContext>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrContext_close0_instantiation_4() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrContext>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrContext>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrContext>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrContext>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrContext_close0_instantiation_5() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrContext>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrContext>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrContext>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrContext>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrContext_close0_instantiation_6() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrContext>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrContext>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrContext>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrContext>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrContext_close0_instantiation_7() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrContext>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrContext>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrContext>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrContext>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrContextThreadSafeProxy_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrContextThreadSafeProxy>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrContextThreadSafeProxy>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrContextThreadSafeProxy>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrContextThreadSafeProxy>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrCaps_close0_instantiation_3() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrCaps>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrCaps>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrCaps>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrCaps>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrSkSLFPFactoryCache_close0_instantiation_3() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrSkSLFPFactoryCache>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrSkSLFPFactoryCache>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrSkSLFPFactoryCache>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrSkSLFPFactoryCache>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrContextThreadSafeProxy_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrContextThreadSafeProxy>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrContextThreadSafeProxy>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrContextThreadSafeProxy>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrContextThreadSafeProxy>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkDeferredDisplayList_LazyProxyData_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkDeferredDisplayList_LazyProxyData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkDeferredDisplayList_LazyProxyData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkDeferredDisplayList_LazyProxyData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkDeferredDisplayList_LazyProxyData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkDeferredDisplayList_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_28() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_32() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_29() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_33() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_GrContext_close0_instantiation_8() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<GrContext>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<GrContext>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<GrContext>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<GrContext>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkDeferredDisplayList_LazyProxyData_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkDeferredDisplayList_LazyProxyData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkDeferredDisplayList_LazyProxyData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkDeferredDisplayList_LazyProxyData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkDeferredDisplayList_LazyProxyData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkSurface_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkStreamAsset_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_3() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_28() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_4() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_5() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_6() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_29() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_7() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_30() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkStreamAsset_close0_instantiation_3() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_8() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkStreamAsset_close0_instantiation_4() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_31() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_9() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_10() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_11() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_12() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_13() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_32() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_14() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkStreamAsset_close0_instantiation_5() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_15() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkStreamAsset_close0_instantiation_6() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_16() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_17() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_18() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_19() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkFontMgr_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkFontMgr>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkFontMgr>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkFontMgr>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkFontMgr>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_33() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_20() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkStreamAsset_close0_instantiation_7() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_21() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkStreamAsset_close0_instantiation_8() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_22() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_23() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_24() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTypeface_close0_instantiation_25() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTypeface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTypeface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_34() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkImageGenerator_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImageFilter_close0_instantiation_3() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImageFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImageFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImageFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImageFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImageFilter_close0_instantiation_4() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImageFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImageFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImageFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImageFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImageFilter_close0_instantiation_5() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImageFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImageFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImageFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImageFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImageFilter_close0_instantiation_6() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImageFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImageFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImageFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImageFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImageFilter_close0_instantiation_7() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImageFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImageFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImageFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImageFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImageFilter_close0_instantiation_8() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImageFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImageFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImageFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImageFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_35() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkImageGenerator_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPicture_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPicture>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPicture>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPicture>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPicture>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_30() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkImageGenerator_close0_instantiation_3() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkMaskFilter_close0_instantiation_3() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkMaskFilter_close0_instantiation_4() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkMaskFilter_close0_instantiation_5() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkMaskFilter_close0_instantiation_6() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkMaskFilter_close0_instantiation_7() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkMaskFilter_close0_instantiation_8() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkMaskFilter_close0_instantiation_9() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkMaskFilter_close0_instantiation_10() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkMaskFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkMaskFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_SkTDArray_open0_SkMultiPictureDraw_DrawData_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<SkTDArray<SkMultiPictureDraw_DrawData>>(),
        16usize,
        concat!(
            "Size of template specialization: ",
            stringify!(SkTDArray<SkMultiPictureDraw_DrawData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<SkTDArray<SkMultiPictureDraw_DrawData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(SkTDArray<SkMultiPictureDraw_DrawData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_SkTDArray_open0_SkMultiPictureDraw_DrawData_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<SkTDArray<SkMultiPictureDraw_DrawData>>(),
        16usize,
        concat!(
            "Size of template specialization: ",
            stringify!(SkTDArray<SkMultiPictureDraw_DrawData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<SkTDArray<SkMultiPictureDraw_DrawData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(SkTDArray<SkMultiPictureDraw_DrawData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_SkTDArray_open0_SkMultiPictureDraw_DrawData_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<SkTDArray<SkMultiPictureDraw_DrawData>>(),
        16usize,
        concat!(
            "Size of template specialization: ",
            stringify!(SkTDArray<SkMultiPictureDraw_DrawData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<SkTDArray<SkMultiPictureDraw_DrawData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(SkTDArray<SkMultiPictureDraw_DrawData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkContourMeasure_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkContourMeasure>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkContourMeasure>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkContourMeasure>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkContourMeasure>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPicture_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPicture>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPicture>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPicture>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPicture>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPicture_close0_instantiation_3() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPicture>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPicture>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPicture>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPicture>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPicture_close0_instantiation_4() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPicture>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPicture>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPicture>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPicture>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_36() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPicture_close0_instantiation_5() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPicture>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPicture>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPicture>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPicture>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation_8() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation_9() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPicture_close0_instantiation_6() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPicture>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPicture>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPicture>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPicture>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPicture_close0_instantiation_7() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPicture>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPicture>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPicture>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPicture>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkDrawable_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkDrawable>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkDrawable>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkDrawable>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkDrawable>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkBBoxHierarchy_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkBBoxHierarchy>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkBBoxHierarchy>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkBBoxHierarchy>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkBBoxHierarchy>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkRecorder_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkRecord_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkRecord>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkRecord>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkRecord>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkRecord>)
        )
    );
}
#[test]
fn __bindgen_test_layout_std_default_delete_open0_SkMiniRecorder_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<std_default_delete>(),
        1usize,
        concat!(
            "Size of template specialization: ",
            stringify!(std_default_delete)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<std_default_delete>(),
        1usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(std_default_delete)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkSurface_close0_instantiation_3() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkSurface_close0_instantiation_4() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkSurface_close0_instantiation_5() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkSurface_close0_instantiation_6() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_31() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkSurface_close0_instantiation_7() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_32() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkSurface_close0_instantiation_8() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_33() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkSurface_close0_instantiation_9() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkSurface_close0_instantiation_10() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkSurface_close0_instantiation_11() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkSurface_close0_instantiation_12() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkSurface_close0_instantiation_13() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkSurface_close0_instantiation_14() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkSurface_close0_instantiation_15() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkSurface>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkSurface>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_34() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkImage_close0_instantiation_35() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkImage>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkImage>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_34() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_SkNVRefCnt_open0_SkTextBlob_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<SkNVRefCnt>(),
        4usize,
        concat!("Size of template specialization: ", stringify!(SkNVRefCnt))
    );
    assert_eq!(
        ::core::mem::align_of::<SkNVRefCnt>(),
        4usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(SkNVRefCnt)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTextBlob_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTextBlob>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTextBlob>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTextBlob>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTextBlob>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTextBlob_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTextBlob>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTextBlob>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTextBlob>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTextBlob>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTextBlob_close0_instantiation_2() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTextBlob>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTextBlob>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTextBlob>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTextBlob>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTextBlob_close0_instantiation_3() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTextBlob>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTextBlob>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTextBlob>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTextBlob>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkData_close0_instantiation_37() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkData>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkData>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTextBlob_close0_instantiation_4() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTextBlob>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTextBlob>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTextBlob>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTextBlob>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkTextBlob_close0_instantiation_5() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkTextBlob>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkTextBlob>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkTextBlob>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkTextBlob>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPathEffect_close0_instantiation_9() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPathEffect_close0_instantiation_10() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkPathEffect_close0_instantiation_11() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkPathEffect>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkPathEffect>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation_10() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_35() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation_11() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation_12() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_36() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation_13() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation_14() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_37() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation_15() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation_16() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorSpace_close0_instantiation_38() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorSpace>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorSpace>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation_17() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkDrawLooper_close0_instantiation_1() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkDrawLooper>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkDrawLooper>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkDrawLooper>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkDrawLooper>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation_18() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation_19() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkShader_close0_instantiation_20() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkShader>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkShader>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorFilter_close0_instantiation_6() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_sk_sp_open0_SkColorFilter_close0_instantiation_7() {
    assert_eq!(
        ::core::mem::size_of::<sk_sp<SkColorFilter>>(),
        8usize,
        concat!(
            "Size of template specialization: ",
            stringify!(sk_sp<SkColorFilter>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<sk_sp<SkColorFilter>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(sk_sp<SkColorFilter>)
        )
    );
}
#[test]
fn __bindgen_test_layout_SkTDArray_open0_SkPathOp_close0_instantiation() {
    assert_eq!(
        ::core::mem::size_of::<SkTDArray<SkPathOp>>(),
        16usize,
        concat!(
            "Size of template specialization: ",
            stringify!(SkTDArray<SkPathOp>)
        )
    );
    assert_eq!(
        ::core::mem::align_of::<SkTDArray<SkPathOp>>(),
        8usize,
        concat!(
            "Alignment of template specialization: ",
            stringify!(SkTDArray<SkPathOp>)
        )
    );
}