::std::os::raw::c_int,
++    ) -> fpos_t,
++  >,
++  pub _write: ::std::option::Option<
++    unsafe extern "C" fn(
++      arg1: *mut ::std::os::raw::c_void,
++      arg2: *const ::std::os::raw::c_char,
++      arg3: ::std::os::raw::c_int,
++    ) -> ::std::os::raw::c_int,
++  >,
++  pub _ub: __sbuf,
++  pub _up: *mut ::std::os::raw::c_uchar,
++  pub _ur: ::std::os::raw::c_int,
++  pub _ubuf: [::std::os::raw::c_uchar; 3usize],
++  pub _nbuf: [::std::os::raw::c_uchar; 1usize],
++  pub _lb: __sbuf,
++  pub _blksize: ::std::os::raw::c_int,
++  pub _offset: fpos_t,
++  pub _fl_mutex: *mut pthread_mutex,
++  pub _fl_owner: *mut pthread,
++  pub _fl_count: ::std::os::raw::c_int,
++  pub _orientation: ::std::os::raw::c_int,
++  pub _mbstate: __mbstate_t,
++  pub _flags2: ::std::os::raw::c_int,
++}
++#[allow(clippy::unnecessary_operation, clippy::identity_op)]
++const _: () = {
++  ["Size of __sFILE"][::std::mem::size_of::<__sFILE>() - 312usize];
++  ["Alignment of __sFILE"][::std::mem::align_of::<__sFILE>() - 8usize];
++  ["Offset of field: __sFILE::_p"]
++    [::std::mem::offset_of!(__sFILE, _p) - 0usize];
++  ["Offset of field: __sFILE::_r"]
++    [::std::mem::offset_of!(__sFILE, _r) - 8usize];
++  ["Offset of field: __sFILE::_w"]
++    [::std::mem::offset_of!(__sFILE, _w) - 12usize];
++  ["Offset of field: __sFILE::_flags"]
++    [::std::mem::offset_of!(__sFILE, _flags) - 16usize];
++  ["Offset of field: __sFILE::_file"]
++    [::std::mem::offset_of!(__sFILE, _file) - 18usize];
++  ["Offset of field: __sFILE::_bf"]
++    [::std::mem::offset_of!(__sFILE, _bf) - 24usize];
++  ["Offset of field: __sFILE::_lbfsize"]
++    [::std::mem::offset_of!(__sFILE, _lbfsize) - 40usize];
++  ["Offset of field: __sFILE::_cookie"]
++    [::std::mem::offset_of!(__sFILE, _cookie) - 48usize];
++  ["Offset of field: __sFILE::_close"]
++    [::std::mem::offset_of!(__sFILE, _close) - 56usize];
++  ["Offset of field: __sFILE::_read"]
++    [::std::mem::offset_of!(__sFILE, _read) - 64usize];
++  ["Offset of field: __sFILE::_seek"]
++    [::std::mem::offset_of!(__sFILE, _seek) - 72usize];
++  ["Offset of field: __sFILE::_write"]
++    [::std::mem::offset_of!(__sFILE, _write) - 80usize];
++  ["Offset of field: __sFILE::_ub"]
++    [::std::mem::offset_of!(__sFILE, _ub) - 88usize];
++  ["Offset of field: __sFILE::_up"]
++    [::std::mem::offset_of!(__sFILE, _up) - 104usize];
++  ["Offset of field: __sFILE::_ur"]
++    [::std::mem::offset_of!(__sFILE, _ur) - 112usize];
++  ["Offset of field: __sFILE::_ubuf"]
++    [::std::mem::offset_of!(__sFILE, _ubuf) - 116usize];
++  ["Offset of field: __sFILE::_nbuf"]
++    [::std::mem::offset_of!(__sFILE, _nbuf) - 119usize];
++  ["Offset of field: __sFILE::_lb"]
++    [::std::mem::offset_of!(__sFILE, _lb) - 120usize];
++  ["Offset of field: __sFILE::_blksize"]
++    [::std::mem::offset_of!(__sFILE, _blksize) - 136usize];
++  ["Offset of field: __sFILE::_offset"]
++    [::std::mem::offset_of!(__sFILE, _offset) - 144usize];
++  ["Offset of field: __sFILE::_fl_mutex"]
++    [::std::mem::offset_of!(__sFILE, _fl_mutex) - 152usize];
++  ["Offset of field: __sFILE::_fl_owner"]
++    [::std::mem::offset_of!(__sFILE, _fl_owner) - 160usize];
++  ["Offset of field: __sFILE::_fl_count"]
++    [::std::mem::offset_of!(__sFILE, _fl_count) - 168usize];
++  ["Offset of field: __sFILE::_orientation"]
++    [::std::mem::offset_of!(__sFILE, _orientation) - 172usize];
++  ["Offset of field: __sFILE::_mbstate"]
++    [::std::mem::offset_of!(__sFILE, _mbstate) - 176usize];
++  ["Offset of field: __sFILE::_flags2"]
++    [::std::mem::offset_of!(__sFILE, _flags2) - 304usize];
++};
++pub type FILE = __sFILE;
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct uv__queue {
++  pub next: *mut uv__queue,
++  pub prev: *mut uv__queue,
++}
++#[allow(clippy::unnecessary_operation, clippy::identity_op)]
++const _: () = {
++  ["Size of uv__queue"][::std::mem::size_of::<uv__queue>() - 16usize];
++  ["Alignment of uv__queue"][::std::mem::align_of::<uv__queue>() - 8usize];
++  ["Offset of field: uv__queue::next"]
++    [::std::mem::offset_of!(uv__queue, next) - 0usize];
++  ["Offset of field: uv__queue::prev"]
++    [::std::mem::offset_of!(uv__queue, prev) - 8usize];
++};
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct pthread {
++  _unused: [u8; 0],
++}
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct pthread_cond {
++  _unused: [u8; 0],
++}
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct pthread_mutex {
++  _unused: [u8; 0],
++}
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct pthread_rwlock {
++  _unused: [u8; 0],
++}
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct pthread_barrier {
++  _unused: [u8; 0],
++}
++pub type pthread_t = *mut pthread;
++pub type pthread_mutex_t = *mut pthread_mutex;
++pub type pthread_cond_t = *mut pthread_cond;
++pub type pthread_key_t = ::std::os::raw::c_int;
++pub type pthread_once_t = pthread_once;
++pub type pthread_rwlock_t = *mut pthread_rwlock;
++pub type pthread_barrier_t = *mut pthread_barrier;
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct pthread_once {
++  pub state: ::std::os::raw::c_int,
++  pub mutex: pthread_mutex_t,
++}
++#[allow(clippy::unnecessary_operation, clippy::identity_op)]
++const _: () = {
++  ["Size of pthread_once"][::std::mem::size_of::<pthread_once>() - 16usize];
++  ["Alignment of pthread_once"]
++    [::std::mem::align_of::<pthread_once>() - 8usize];
++  ["Offset of field: pthread_once::state"]
++    [::std::mem::offset_of!(pthread_once, state) - 0usize];
++  ["Offset of field: pthread_once::mutex"]
++    [::std::mem::offset_of!(pthread_once, mutex) - 8usize];
++};
++pub type gid_t = __gid_t;
++pub type in_addr_t = __uint32_t;
++pub type in_port_t = __uint16_t;
++pub type ino_t = __ino_t;
++pub type mode_t = __mode_t;
++pub type pid_t = __pid_t;
++pub type uid_t = __uid_t;
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct dirent {
++  pub d_fileno: ino_t,
++  pub d_off: off_t,
++  pub d_reclen: __uint16_t,
++  pub d_type: __uint8_t,
++  pub d_pad0: __uint8_t,
++  pub d_namlen: __uint16_t,
++  pub d_pad1: __uint16_t,
++  pub d_name: [::std::os::raw::c_char; 256usize],
++}
++#[allow(clippy::unnecessary_operation, clippy::identity_op)]
++const _: () = {
++  ["Size of dirent"][::std::mem::size_of::<dirent>() - 280usize];
++  ["Alignment of dirent"][::std::mem::align_of::<dirent>() - 8usize];
++  ["Offset of field: dirent::d_fileno"]
++    [::std::mem::offset_of!(dirent, d_fileno) - 0usize];
++  ["Offset of field: dirent::d_off"]
++    [::std::mem::offset_of!(dirent, d_off) - 8usize];
++  ["Offset of field: dirent::d_reclen"]
++    [::std::mem::offset_of!(dirent, d_reclen) - 16usize];
++  ["Offset of field: dirent::d_type"]
++    [::std::mem::offset_of!(dirent, d_type) - 18usize];
++  ["Offset of field: dirent::d_pad0"]
++    [::std::mem::offset_of!(dirent, d_pad0) - 19usize];
++  ["Offset of field: dirent::d_namlen"]
++    [::std::mem::offset_of!(dirent, d_namlen) - 20usize];
++  ["Offset of field: dirent::d_pad1"]
++    [::std::mem::offset_of!(dirent, d_pad1) - 22usize];
++  ["Offset of field: dirent::d_name"]
++    [::std::mem::offset_of!(dirent, d_name) - 24usize];
++};
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct _dirdesc {
++  _unused: [u8; 0],
++}
++pub type DIR = _dirdesc;
++pub type sa_family_t = __sa_family_t;
++pub type socklen_t = __socklen_t;
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct sockaddr {
++  pub sa_len: ::std::os::raw::c_uchar,
++  pub sa_family: sa_family_t,
++  pub sa_data: [::std::os::raw::c_char; 14usize],
++}
++#[allow(clippy::unnecessary_operation, clippy::identity_op)]
++const _: () = {
++  ["Size of sockaddr"][::std::mem::size_of::<sockaddr>() - 16usize];
++  ["Alignment of sockaddr"][::std::mem::align_of::<sockaddr>() - 1usize];
++  ["Offset of field: sockaddr::sa_len"]
++    [::std::mem::offset_of!(sockaddr, sa_len) - 0usize];
++  ["Offset of field: sockaddr::sa_family"]
++    [::std::mem::offset_of!(sockaddr, sa_family) - 1usize];
++  ["Offset of field: sockaddr::sa_data"]
++    [::std::mem::offset_of!(sockaddr, sa_data) - 2usize];
++};
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct sockaddr_storage {
++  pub ss_len: ::std::os::raw::c_uchar,
++  pub ss_family: sa_family_t,
++  pub __ss_pad1: [::std::os::raw::c_char; 6usize],
++  pub __ss_align: __int64_t,
++  pub __ss_pad2: [::std::os::raw::c_char; 112usize],
++}
++#[allow(clippy::unnecessary_operation, clippy::identity_op)]
++const _: () = {
++  ["Size of sockaddr_storage"]
++    [::std::mem::size_of::<sockaddr_storage>() - 128usize];
++  ["Alignment of sockaddr_storage"]
++    [::std::mem::align_of::<sockaddr_storage>() - 8usize];
++  ["Offset of field: sockaddr_storage::ss_len"]
++    [::std::mem::offset_of!(sockaddr_storage, ss_len) - 0usize];
++  ["Offset of field: sockaddr_storage::ss_family"]
++    [::std::mem::offset_of!(sockaddr_storage, ss_family) - 1usize];
++  ["Offset of field: sockaddr_storage::__ss_pad1"]
++    [::std::mem::offset_of!(sockaddr_storage, __ss_pad1) - 2usize];
++  ["Offset of field: sockaddr_storage::__ss_align"]
++    [::std::mem::offset_of!(sockaddr_storage, __ss_align) - 8usize];
++  ["Offset of field: sockaddr_storage::__ss_pad2"]
++    [::std::mem::offset_of!(sockaddr_storage, __ss_pad2) - 16usize];
++};
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct in_addr {
++  pub s_addr: in_addr_t,
++}
++#[allow(clippy::unnecessary_operation, clippy::identity_op)]
++const _: () = {
++  ["Size of in_addr"][::std::mem::size_of::<in_addr>() - 4usize];
++  ["Alignment of in_addr"][::std::mem::align_of::<in_addr>() - 4usize];
++  ["Offset of field: in_addr::s_addr"]
++    [::std::mem::offset_of!(in_addr, s_addr) - 0usize];
++};
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct sockaddr_in {
++  pub sin_len: u8,
++  pub sin_family: sa_family_t,
++  pub sin_port: in_port_t,
++  pub sin_addr: in_addr,
++  pub sin_zero: [::std::os::raw::c_char; 8usize],
++}
++#[allow(clippy::unnecessary_operation, clippy::identity_op)]
++const _: () = {
++  ["Size of sockaddr_in"][::std::mem::size_of::<sockaddr_in>() - 16usize];
++  ["Alignment of sockaddr_in"][::std::mem::align_of::<sockaddr_in>() - 4usize];
++  ["Offset of field: sockaddr_in::sin_len"]
++    [::std::mem::offset_of!(sockaddr_in, sin_len) - 0usize];
++  ["Offset of field: sockaddr_in::sin_family"]
++    [::std::mem::offset_of!(sockaddr_in, sin_family) - 1usize];
++  ["Offset of field: sockaddr_in::sin_port"]
++    [::std::mem::offset_of!(sockaddr_in, sin_port) - 2usize];
++  ["Offset of field: sockaddr_in::sin_addr"]
++    [::std::mem::offset_of!(sockaddr_in, sin_addr) - 4usize];
++  ["Offset of field: sockaddr_in::sin_zero"]
++    [::std::mem::offset_of!(sockaddr_in, sin_zero) - 8usize];
++};
++#[repr(C)]
++#[derive(Copy, Clone)]
++pub struct in6_addr {
++  pub __u6_addr: in6_addr__bindgen_ty_1,
++}
++#[repr(C)]
++#[derive(Copy, Clone)]
++pub union in6_addr__bindgen_ty_1 {
++  pub __u6_addr8: [u8; 16usize],
++  pub __u6_addr16: [u16; 8usize],
++  pub __u6_addr32: [u32; 4usize],
++}
++#[allow(clippy::unnecessary_operation, clippy::identity_op)]
++const _: () = {
++  ["Size of in6_addr__bindgen_ty_1"]
++    [::std::mem::size_of::<in6_addr__bindgen_ty_1>() - 16usize];
++  ["Alignment of in6_addr__bindgen_ty_1"]
++    [::std::mem::align_of::<in6_addr__bindgen_ty_1>() - 4usize];
++  ["Offset of field: in6_addr__bindgen_ty_1::__u6_addr8"]
++    [::std::mem::offset_of!(in6_addr__bindgen_ty_1, __u6_addr8) - 0usize];
++  ["Offset of field: in6_addr__bindgen_ty_1::__u6_addr16"]
++    [::std::mem::offset_of!(in6_addr__bindgen_ty_1, __u6_addr16) - 0usize];
++  ["Offset of field: in6_addr__bindgen_ty_1::__u6_addr32"]
++    [::std::mem::offset_of!(in6_addr__bindgen_ty_1, __u6_addr32) - 0usize];
++};
++#[allow(clippy::unnecessary_operation, clippy::identity_op)]
++const _: () = {
++  ["Size of in6_addr"][::std::mem::size_of::<in6_addr>() - 16usize];
++  ["Alignment of in6_addr"][::std::mem::align_of::<in6_addr>() - 4usize];
++  ["Offset of field: in6_addr::__u6_addr"]
++    [::std::mem::offset_of!(in6_addr, __u6_addr) - 0usize];
++};
++#[repr(C)]
++#[derive(Copy, Clone)]
++pub struct sockaddr_in6 {
++  pub sin6_len: u8,
++  pub sin6_family: sa_family_t,
++  pub sin6_port: in_port_t,
++  pub sin6_flowinfo: u32,
++  pub sin6_addr: in6_addr,
++  pub sin6_scope_id: u32,
++}
++#[allow(clippy::unnecessary_operation, clippy::identity_op)]
++const _: () = {
++  ["Size of sockaddr_in6"][::std::mem::size_of::<sockaddr_in6>() - 28usize];
++  ["Alignment of sockaddr_in6"]
++    [::std::mem::align_of::<sockaddr_in6>() - 4usize];
++  ["Offset of field: sockaddr_in6::sin6_len"]
++    [::std::mem::offset_of!(sockaddr_in6, sin6_len) - 0usize];
++  ["Offset of field: sockaddr_in6::sin6_family"]
++    [::std::mem::offset_of!(sockaddr_in6, sin6_family) - 1usize];
++  ["Offset of field: sockaddr_in6::sin6_port"]
++    [::std::mem::offset_of!(sockaddr_in6, sin6_port) - 2usize];
++  ["Offset of field: sockaddr_in6::sin6_flowinfo"]
++    [::std::mem::offset_of!(sockaddr_in6, sin6_flowinfo) - 4usize];
++  ["Offset of field: sockaddr_in6::sin6_addr"]
++    [::std::mem::offset_of!(sockaddr_in6, sin6_addr) - 8usize];
++  ["Offset of field: sockaddr_in6::sin6_scope_id"]
++    [::std::mem::offset_of!(sockaddr_in6, sin6_scope_id) - 24usize];
++};
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct addrinfo {
++  pub ai_flags: ::std::os::raw::c_int,
++  pub ai_family: ::std::os::raw::c_int,
++  pub ai_socktype: ::std::os::raw::c_int,
++  pub ai_protocol: ::std::os::raw::c_int,
++  pub ai_addrlen: socklen_t,
++  pub ai_canonname: *mut ::std::os::raw::c_char,
++  pub ai_addr: *mut sockaddr,
++  pub ai_next: *mut addrinfo,
++}
++#[allow(clippy::unnecessary_operation, clippy::identity_op)]
++const _: () = {
++  ["Size of addrinfo"][::std::mem::size_of::<addrinfo>() - 48usize];
++  ["Alignment of addrinfo"][::std::mem::align_of::<addrinfo>() - 8usize];
++  ["Offset of field: addrinfo::ai_flags"]
++    [::std::mem::offset_of!(addrinfo, ai_flags) - 0usize];
++  ["Offset of field: addrinfo::ai_family"]
++    [::std::mem::offset_of!(addrinfo, ai_family) - 4usize];
++  ["Offset of field: addrinfo::ai_socktype"]
++    [::std::mem::offset_of!(addrinfo, ai_socktype) - 8usize];
++  ["Offset of field: addrinfo::ai_protocol"]
++    [::std::mem::offset_of!(addrinfo, ai_protocol) - 12usize];
++  ["Offset of field: addrinfo::ai_addrlen"]
++    [::std::mem::offset_of!(addrinfo, ai_addrlen) - 16usize];
++  ["Offset of field: addrinfo::ai_canonname"]
++    [::std::mem::offset_of!(addrinfo, ai_canonname) - 24usize];
++  ["Offset of field: addrinfo::ai_addr"]
++    [::std::mem::offset_of!(addrinfo, ai_addr) - 32usize];
++  ["Offset of field: addrinfo::ai_next"]
++    [::std::mem::offset_of!(addrinfo, ai_next) - 40usize];
++};
++pub type tcflag_t = ::std::os::raw::c_uint;
++pub type cc_t = ::std::os::raw::c_uchar;
++pub type speed_t = ::std::os::raw::c_uint;
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct termios {
++  pub c_iflag: tcflag_t,
++  pub c_oflag: tcflag_t,
++  pub c_cflag: tcflag_t,
++  pub c_lflag: tcflag_t,
++  pub c_cc: [cc_t; 20usize],
++  pub c_ispeed: speed_t,
++  pub c_ospeed: speed_t,
++}
++#[allow(clippy::unnecessary_operation, clippy::identity_op)]
++const _: () = {
++  ["Size of termios"][::std::mem::size_of::<termios>() - 44usize];
++  ["Alignment of termios"][::std::mem::align_of::<termios>() - 4usize];
++  ["Offset of field: termios::c_iflag"]
++    [::std::mem::offset_of!(termios, c_iflag) - 0usize];
++  ["Offset of field: termios::c_oflag"]
++    [::std::mem::offset_of!(termios, c_oflag) - 4usize];
++  ["Offset of field: termios::c_cflag"]
++    [::std::mem::offset_of!(termios, c_cflag) - 8usize];
++  ["Offset of field: termios::c_lflag"]
++    [::std::mem::offset_of!(termios, c_lflag) - 12usize];
++  ["Offset of field: termios::c_cc"]
++    [::std::mem::offset_of!(termios, c_cc) - 16usize];
++  ["Offset of field: termios::c_ispeed"]
++    [::std::mem::offset_of!(termios, c_ispeed) - 36usize];
++  ["Offset of field: termios::c_ospeed"]
++    [::std::mem::offset_of!(termios, c_ospeed) - 40usize];
++};
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct _usem2 {
++  pub _count: __uint32_t,
++  pub _flags: __uint32_t,
++}
++#[allow(clippy::unnecessary_operation, clippy::identity_op)]
++const _: () = {
++  ["Size of _usem2"][::std::mem::size_of::<_usem2>() - 8usize];
++  ["Alignment of _usem2"][::std::mem::align_of::<_usem2>() - 4usize];
++  ["Offset of field: _usem2::_count"]
++    [::std::mem::offset_of!(_usem2, _count) - 0usize];
++  ["Offset of field: _usem2::_flags"]
++    [::std::mem::offset_of!(_usem2, _flags) - 4usize];
++};
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct _sem {
++  pub _magic: __uint32_t,
++  pub _kern: _usem2,
++  pub _padding: __uint32_t,
++}
++#[allow(clippy::unnecessary_operation, clippy::identity_op)]
++const _: () = {
++  ["Size of _sem"][::std::mem::size_of::<_sem>() - 16usize];
++  ["Alignment of _sem"][::std::mem::align_of::<_sem>() - 4usize];
++  ["Offset of field: _sem::_magic"]
++    [::std::mem::offset_of!(_sem, _magic) - 0usize];
++  ["Offset of field: _sem::_kern"]
++    [::std::mem::offset_of!(_sem, _kern) - 4usize];
++  ["Offset of field: _sem::_padding"]
++    [::std::mem::offset_of!(_sem, _padding) - 12usize];
++};
++pub type sem_t = _sem;
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct uv__work {
++  pub work: ::std::option::Option<unsafe extern "C" fn(w: *mut uv__work)>,
++  pub done: ::std::option::Option<
++    unsafe extern "C" fn(w: *mut uv__work, status: ::std::os::raw::c_int),
++  >,
++  pub loop_: *mut uv_loop_s,
++  pub wq: uv__queue,
++}
++#[allow(clippy::unnecessary_operation, clippy::identity_op)]
++const _: () = {
++  ["Size of uv__work"][::std::mem::size_of::<uv__work>() - 40usize];
++  ["Alignment of uv__work"][::std::mem::align_of::<uv__work>() - 8usize];
++  ["Offset of field: uv__work::work"]
++    [::std::mem::offset_of!(uv__work, work) - 0usize];
++  ["Offset of field: uv__work::done"]
++    [::std::mem::offset_of!(uv__work, done) - 8usize];
++  ["Offset of field: uv__work::loop_"]
++    [::std::mem::offset_of!(uv__work, loop_) - 16usize];
++  ["Offset of field: uv__work::wq"]
++    [::std::mem::offset_of!(uv__work, wq) - 24usize];
++};
++pub type uv__io_cb = ::std::option::Option<
++  unsafe extern "C" fn(
++    loop_: *mut uv_loop_s,
++    w: *mut uv__io_s,
++    events: ::std::os::raw::c_uint,
++  ),
++>;
++pub type uv__io_t = uv__io_s;
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct uv__io_s {
++  pub cb: uv__io_cb,
++  pub pending_queue: uv__queue,
++  pub watcher_queue: uv__queue,
++  pub pevents: ::std::os::raw::c_uint,
++  pub events: ::std::os::raw::c_uint,
++  pub fd: ::std::os::raw::c_int,
++  pub rcount: ::std::os::raw::c_int,
++  pub wcount: ::std::os::raw::c_int,
++}
++#[allow(clippy::unnecessary_operation, clippy::identity_op)]
++const _: () = {
++  ["Size of uv__io_s"][::std::mem::size_of::<uv__io_s>() - 64usize];
++  ["Alignment of uv__io_s"][::std::mem::align_of::<uv__io_s>() - 8usize];
++  ["Offset of field: uv__io_s::cb"]
++    [::std::mem::offset_of!(uv__io_s, cb) - 0usize];
++  ["Offset of field: uv__io_s::pending_queue"]
++    [::std::mem::offset_of!(uv__io_s, pending_queue) - 8usize];
++  ["Offset of field: uv__io_s::watcher_queue"]
++    [::std::mem::offset_of!(uv__io_s, watcher_queue) - 24usize];
++  ["Offset of field: uv__io_s::pevents"]
++    [::std::mem::offset_of!(uv__io_s, pevents) - 40usize];
++  ["Offset of field: uv__io_s::events"]
++    [::std::mem::offset_of!(uv__io_s, events) - 44usize];
++  ["Offset of field: uv__io_s::fd"]
++    [::std::mem::offset_of!(uv__io_s, fd) - 48usize];
++  ["Offset of field: uv__io_s::rcount"]
++    [::std::mem::offset_of!(uv__io_s, rcount) - 52usize];
++  ["Offset of field: uv__io_s::wcount"]
++    [::std::mem::offset_of!(uv__io_s, wcount) - 56usize];
++};
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct uv_buf_t {
++  pub base: *mut ::std::os::raw::c_char,
++  pub len: usize,
++}
++#[allow(clippy::unnecessary_operation, clippy::identity_op)]
++const _: () = {
++  ["Size of uv_buf_t"][::std::mem::size_of::<uv_buf_t>() - 16usize];
++  ["Alignment of uv_buf_t"][::std::mem::align_of::<uv_buf_t>() - 8usize];
++  ["Offset of field: uv_buf_t::base"]
++    [::std::mem::offset_of!(uv_buf_t, base) - 0usize];
++  ["Offset of field: uv_buf_t::len"]
++    [::std::mem::offset_of!(uv_buf_t, len) - 8usize];
++};
++pub type uv_file = ::std::os::raw::c_int;
++pub type uv_os_sock_t = ::std::os::raw::c_int;
++pub type uv_os_fd_t = ::std::os::raw::c_int;
++pub type uv_pid_t = pid_t;
++pub type uv_once_t = pthread_once_t;
++pub type uv_thread_t = pthread_t;
++pub type uv_mutex_t = pthread_mutex_t;
++pub type uv_rwlock_t = pthread_rwlock_t;
++pub type uv_sem_t = sem_t;
++pub type uv_cond_t = pthread_cond_t;
++pub type uv_key_t = pthread_key_t;
++pub type uv_barrier_t = pthread_barrier_t;
++pub type uv_gid_t = gid_t;
++pub type uv_uid_t = uid_t;
++pub type uv__dirent_t = dirent;
++#[repr(C)]
++#[derive(Debug, Copy, Clone)]
++pub struct uv_lib_t {
++  pub handle: *mut ::std::os::raw::c_void,
++  pub errmsg: *mut ::std::os::raw::c_char,
++}
++#[allow(clippy::unnecessary_operation, clippy::identity_op)]
++const _: () = {
++  ["Size of uv_lib_t"][::std::mem::size_of::<uv_lib_t>() - 16usize];
++  ["Alignment of uv_lib_t"][::std::mem::align_of::<uv_lib_t>() - 8usize];
++  ["Offset of field: uv_lib_t::handle"]
++    [::std::mem::offset_of!(uv_lib_t, handle) - 0usize];
++  ["Offset of field: uv_lib_t::errmsg"]
++    [::std::mem::offset_of!(uv_lib_t, errmsg) - 8usize];
++};
++impl uv_errno_t {
++  pub const UV_E2BIG: uv_errno_t = uv_errno_t(-7);
++}
++impl uv_errno_t {
++  pub const UV_EACCES: uv_errno_t = uv_errno_t(-13);
++}
++impl uv_errno_t {
++  pub const UV_EADDRINUSE: uv_errno_t = uv_errno_t(-48);
++}
++impl uv_errno_t {
++  pub const UV_EADDRNOTAVAIL: uv_errno_t = uv_errno_t(-49);
++}
++impl uv_errno_t {
++  pub const UV_EAFNOSUPPORT: uv_errno_t = uv_errno_t(-47);
++}
++impl uv_errno_t {
++  pub const UV_EAGAIN: uv_errno_t = uv_errno_t(-35);
++}
++impl uv_errno_t {
++  pub const UV_EAI_ADDRFAMILY: uv_errno_t = uv_errno_t(-3000);
++}
++impl uv_errno_t {
++  pub const UV_EAI_AGAIN: uv_errno_t = uv_errno_t(-3001);
++}
++impl uv_errno_t {
++  pub const UV_EAI_BADFLAGS: uv_errno_t = uv_errno_t(-3002);
++}
++impl uv_errno_t {
++  pub const UV_EAI_BADHINTS: uv_errno_t = uv_errno_t(-3013);
++}
++impl uv_errno_t {
++  pub const UV_EAI_CANCELED: uv_errno_t = uv_errno_t(-3003);
++}
++impl uv_errno_t {
++  pub const UV_EAI_FAIL: uv_errno_t = uv_errno_t(-3004);
++}
++impl uv_errno_t {
++  pub const UV_EAI_FAMILY: uv_errno_t = uv_errno_t(-3005);
++}
++impl uv_errno_t {
++  pub const UV_EAI_MEMORY: uv_errno_t = uv_errno_t(-3006);
++}
++impl uv_errno_t {
++  pub const UV_EAI_NODATA: uv_errno_t = uv_errno_t(-3007);
++}
++impl uv_errno_t {
++  pub const UV_EAI_NONAME: uv_errno_t = uv_errno_t(-3008);
++}
++impl uv_errno_t {
++  pub const UV_EAI_OVERFLOW: uv_errno_t = uv_errno_t(-3009);
++}
++impl uv_errno_t {
++  pub const UV_EAI_PROTOCOL: uv_errno_t = uv_errno_t(-3014);
++}
++impl uv_errno_t {
++  pub const UV_EAI_SERVICE: uv_errno_t = uv_errno_t(-3010);
++}
++impl uv_errno_t {
++  pub const UV_EAI_SOCKTYPE: uv_errno_t = uv_errno_t(-3011);
++}
++impl uv_errno_t {
++  pub const UV_EALREADY: uv_errno_t = uv_errno_t(-37);
++}
++impl uv_errno_t {
++  pub const UV_EBADF: uv_errno_t = uv_errno_t(-9);
++}
++impl uv_errno_t {
++  pub const UV_EBUSY: uv_errno_t = uv_errno_t(-16);
++}
++impl uv_errno_t {
++  pub const UV_ECANCELED: uv_errno_t = uv_errno_t(-85);
++}
++impl uv_errno_t {
++  pub const UV_ECHARSET: uv_errno_t = uv_errno_t(-4080);
++}
++impl uv_errno_t {
++  pub const UV_ECONNABORTED: uv_errno_t = uv_errno_t(-53);
++}
++impl uv_errno_t {
++  pub const UV_ECONNREFUSED: uv_errno_t = uv_errno_t(-61);
++}
++impl uv_errno_t {
++  pub const UV_ECONNRESET: uv_errno_t = uv_errno_t(-54);
++}
++impl uv_errno_t {
++  pub const UV_EDESTADDRREQ: uv_errno_t = uv_errno_t(-39);
++}
++impl uv_errno_t {
++  pub const UV_EEXIST: uv_errno_t = uv_errno_t(-17);
++}
++impl uv_errno_t {
++  pub const UV_EFAULT: uv_errno_t = uv_errno_t(-14);
++}
++impl uv_errno_t {
++  pub const UV_EFBIG: uv_errno_t = uv_errno_t(-27);
++}
++impl uv_errno_t {
++  pub const UV_EHOSTUNREACH: uv_errno_t = uv_errno_t(-65);
++}
++impl uv_errno_t {
++  pub const UV_EINTR: uv_errno_t = uv_errno_t(-4);
++}
++impl uv_errno_t {
++  pub const UV_EINVAL: uv_errno_t = uv_errno_t(-22);
++}
++impl uv_errno_t {
++  pub const UV_EIO: uv_errno_t = uv_errno_t(-5);
++}
++impl uv_errno_t {
++  pub const UV_EISCONN: uv_errno_t = uv_errno_t(-56);
++}
++impl uv_errno_t {
++  pub const UV_EISDIR: uv_errno_t = uv_errno_t(-21);
++}
++impl uv_errno_t {
++  pub const UV_ELOOP: uv_errno_t = uv_errno_t(-62);
++}
++impl uv_errno_t {
++  pub const UV_EMFILE: uv_errno_t = uv_errno_t(-24);
++}
++impl uv_errno_t {
++  pub const UV_EMSGSIZE: uv_errno_t = uv_errno_t(-40);
++}
++impl uv_errno_t {
++  pub const UV_ENAMETOOLONG: uv_errno_t = uv_errno_t(-63);
++}
++impl uv_errno_t {
++  pub const UV_ENETDOWN: uv_errno_t = uv_errno_t(-50);
++}
++impl uv_errno_t {
++  pub const UV_ENETUNREACH: uv_errno_t = uv_errno_t(-51);
++}
++impl uv_errno_t {
++  pub const UV_ENFILE: uv_errno_t = uv_errno_t(-23);
++}
++impl uv_errno_t {
++  pub const UV_ENOBUFS: uv_errno_t = uv_errno_t(-55);
++}
++impl uv_errno_t {
++  pub const UV_ENODEV: uv_errno_t = uv_errno_t(-19);
++}
++impl uv_errno_t {
++  pub const UV_ENOENT: uv_errno_t = uv_errno_t(-2);
++}
++impl uv_errno_t {
++  pub const UV_ENOMEM: uv_errno_t = uv_errno_t(-12);
++}
++impl uv_errno_t {
++  pub const UV_ENONET: uv_errno_t = uv_errno_t(-4056);
++}
++impl uv_errno_t {
++  pub const UV_ENOPROTOOPT: uv_errno_t = uv_errno_t(-42);
++}
++impl uv_errno_t {
++  pub const UV_ENOSPC: uv_errno_t = uv_errno_t(-28);
++}
++impl uv_errno_t {
++  pub const UV_ENOSYS: uv_errno_t = uv_errno_t(-78);
++}
++impl uv_errno_t {
++  pub const UV_ENOTCONN: uv_errno_t = uv_errno_t(-57);
++}
++impl uv_errno_t {
++  pub const UV_ENOTDIR: uv_errno_t = uv_errno_t(-20);
++}
++impl uv_errno_t {
++  pub const UV_ENOTEMPTY: uv_errno_t = uv_errno_t(-66);
++}
++impl uv_errno_t {
++  pub const UV_ENOTSOCK: uv_errno_t = uv_errno_t(-38);
++}
++impl uv_errno_t {
++  pub const UV_ENOTSUP: uv_errno_t = uv_errno_t(-45);
++}
++impl uv_errno_t {
++  pub const UV_EOVERFLOW: uv_errno_t = uv_errno_t(-84);
++}
++impl uv_errno_t {
++  pub const UV_EPERM: uv_errno_t = uv_errno_t(-1);
++}
++impl uv_errno_t {
++  pub const UV_EPIPE: uv_errno_t = uv_errno_t(-32);
++}
++impl uv_errno_t {
++  pub const UV_EPROTO: uv_errno_t = uv_errno_t(-92);
++}
++impl uv_errno_t {
++  pub const UV_EPROTONOSUPPORT: uv_errno_t = uv_errno_t(-43);
++}
++impl uv_errno_t {
++  pub const UV_EPROTOTYPE: uv_errno_t = uv_errno_t(-41);
++}
++impl uv_errno_t {
++  pub const UV_ERANGE: uv_errno_t = uv_errno_t(-34);
++}
++impl uv_errno_t {
++  pub const UV_EROFS: uv_errno_t = uv_errno_t(-30);
++}
++impl uv_errno_t {
++  pub const UV_ESHUTDOWN: uv_errno_t = uv_errno_t(-58);
++}
++impl uv_errno_t {
++  pub const UV_ESPIPE: uv_errno_t = uv_errno_t(-29);
++}
++impl uv_errno_t {
++  pub const UV_ESRCH: uv_errno_t = uv_errno_t(-3);
++}
++impl uv_errno_t {
++  pub const UV_ETIMEDOUT: uv_errno_t = uv_errno_t(-60);
++}
++impl uv_errno_t {
++  pub const UV_ETXTBSY: uv_errno_t = uv_errno_t(-26);
++}
++impl uv_errno_t {
++  pub const UV_EXDEV: uv_errno_t = uv_errno_t(-18);
++}
++impl uv_errno_t {
++  pub const UV_UNKNOWN: uv_errno_t = uv_errno_t(-4094);
++}
++impl uv_errno_t {
++  pub const UV_EOF: uv_errno_t = uv_errno_t(-4095);
++}
++impl uv_errno_t {
++  pub const UV_ENXIO: uv_errno_t = uv_errno_t(-6);
++}
++impl uv_errno_t {
++  pub const UV_EMLINK: uv_errno_t = uv_errno_t(-31);
++}
++impl uv_errno_t {
++  pub const UV_EHOSTDOWN: uv_errno_t = uv_errno_t(-64);
++}
++impl uv_errno_t {
++  pub const UV_EREMOTEIO: uv_errno_t = uv_errno_t(-4030);
++}
++impl uv_errno_t {
++  pub const UV_ENOTTY: uv_errno_t = uv_errno_t(-25);
++}
++impl uv_errno_t {
++  pub const UV_EFTYPE: uv_errno_t = uv_errno_t(-79);
++}
++impl uv_errno_t {
++  pub const UV_EILSEQ: uv_errno_t = uv_errno_t(-86);
++}
*** 6454 LINES SKIPPED ***