biodiff_wfa2_sys/

lib.rs

/* automatically generated by rust-bindgen 0.69.4 */

#![allow(non_upper_case_globals,non_snake_case,non_camel_case_types,unused)]
pub type FILE = libc::FILE;
pub type timespec = libc::timespec;

pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
pub type __time_t = ::std::os::raw::c_long;
pub type __syscall_slong_t = ::std::os::raw::c_long;
pub const heatmap_type_heatmap_min: heatmap_type = 0;
pub const heatmap_type_heatmap_max: heatmap_type = 1;
pub const heatmap_type_heatmap_value: heatmap_type = 2;
pub type heatmap_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct heatmap_t {
    pub type_: heatmap_type,
    pub num_rows: ::std::os::raw::c_int,
    pub num_columns: ::std::os::raw::c_int,
    pub min_v: ::std::os::raw::c_int,
    pub max_v: ::std::os::raw::c_int,
    pub min_h: ::std::os::raw::c_int,
    pub max_h: ::std::os::raw::c_int,
    pub binning_factor: f32,
    pub values: *mut *mut ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_heatmap_t() {
    const UNINIT: ::std::mem::MaybeUninit<heatmap_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<heatmap_t>(),
        40usize,
        concat!("Size of: ", stringify!(heatmap_t))
    );
    assert_eq!(
        ::std::mem::align_of::<heatmap_t>(),
        8usize,
        concat!("Alignment of ", stringify!(heatmap_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(heatmap_t),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_rows) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(heatmap_t),
            "::",
            stringify!(num_rows)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_columns) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(heatmap_t),
            "::",
            stringify!(num_columns)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).min_v) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(heatmap_t),
            "::",
            stringify!(min_v)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_v) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(heatmap_t),
            "::",
            stringify!(max_v)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).min_h) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(heatmap_t),
            "::",
            stringify!(min_h)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_h) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(heatmap_t),
            "::",
            stringify!(max_h)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).binning_factor) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(heatmap_t),
            "::",
            stringify!(binning_factor)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).values) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(heatmap_t),
            "::",
            stringify!(values)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct profiler_counter_t {
    pub total: u64,
    pub samples: u64,
    pub min: u64,
    pub max: u64,
    pub m_oldM: f64,
    pub m_newM: f64,
    pub m_oldS: f64,
    pub m_newS: f64,
}
#[test]
fn bindgen_test_layout_profiler_counter_t() {
    const UNINIT: ::std::mem::MaybeUninit<profiler_counter_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<profiler_counter_t>(),
        64usize,
        concat!("Size of: ", stringify!(profiler_counter_t))
    );
    assert_eq!(
        ::std::mem::align_of::<profiler_counter_t>(),
        8usize,
        concat!("Alignment of ", stringify!(profiler_counter_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).total) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(profiler_counter_t),
            "::",
            stringify!(total)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).samples) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(profiler_counter_t),
            "::",
            stringify!(samples)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).min) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(profiler_counter_t),
            "::",
            stringify!(min)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(profiler_counter_t),
            "::",
            stringify!(max)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m_oldM) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(profiler_counter_t),
            "::",
            stringify!(m_oldM)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m_newM) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(profiler_counter_t),
            "::",
            stringify!(m_newM)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m_oldS) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(profiler_counter_t),
            "::",
            stringify!(m_oldS)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m_newS) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(profiler_counter_t),
            "::",
            stringify!(m_newS)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct profiler_timer_t {
    pub begin_timer: timespec,
    pub time_ns: profiler_counter_t,
    pub accumulated: u64,
}
#[test]
fn bindgen_test_layout_profiler_timer_t() {
    const UNINIT: ::std::mem::MaybeUninit<profiler_timer_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<profiler_timer_t>(),
        88usize,
        concat!("Size of: ", stringify!(profiler_timer_t))
    );
    assert_eq!(
        ::std::mem::align_of::<profiler_timer_t>(),
        8usize,
        concat!("Alignment of ", stringify!(profiler_timer_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).begin_timer) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(profiler_timer_t),
            "::",
            stringify!(begin_timer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).time_ns) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(profiler_timer_t),
            "::",
            stringify!(time_ns)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).accumulated) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(profiler_timer_t),
            "::",
            stringify!(accumulated)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct vector_t {
    pub memory: *mut ::std::os::raw::c_void,
    pub used: u64,
    pub element_size: u64,
    pub elements_allocated: u64,
}
#[test]
fn bindgen_test_layout_vector_t() {
    const UNINIT: ::std::mem::MaybeUninit<vector_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<vector_t>(),
        32usize,
        concat!("Size of: ", stringify!(vector_t))
    );
    assert_eq!(
        ::std::mem::align_of::<vector_t>(),
        8usize,
        concat!("Alignment of ", stringify!(vector_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).memory) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(vector_t),
            "::",
            stringify!(memory)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).used) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(vector_t),
            "::",
            stringify!(used)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).element_size) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(vector_t),
            "::",
            stringify!(element_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).elements_allocated) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(vector_t),
            "::",
            stringify!(elements_allocated)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mm_allocator_t {
    pub request_ticker: u64,
    pub segment_size: u64,
    pub segments: *mut vector_t,
    pub segments_free: *mut vector_t,
    pub current_segment_idx: u64,
    pub malloc_requests: *mut vector_t,
    pub malloc_requests_freed: u64,
}
#[test]
fn bindgen_test_layout_mm_allocator_t() {
    const UNINIT: ::std::mem::MaybeUninit<mm_allocator_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<mm_allocator_t>(),
        56usize,
        concat!("Size of: ", stringify!(mm_allocator_t))
    );
    assert_eq!(
        ::std::mem::align_of::<mm_allocator_t>(),
        8usize,
        concat!("Alignment of ", stringify!(mm_allocator_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).request_ticker) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(mm_allocator_t),
            "::",
            stringify!(request_ticker)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).segment_size) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(mm_allocator_t),
            "::",
            stringify!(segment_size)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).segments) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(mm_allocator_t),
            "::",
            stringify!(segments)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).segments_free) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(mm_allocator_t),
            "::",
            stringify!(segments_free)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).current_segment_idx) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(mm_allocator_t),
            "::",
            stringify!(current_segment_idx)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).malloc_requests) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(mm_allocator_t),
            "::",
            stringify!(malloc_requests)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).malloc_requests_freed) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(mm_allocator_t),
            "::",
            stringify!(malloc_requests_freed)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct linear_penalties_t {
    pub match_: ::std::os::raw::c_int,
    pub mismatch: ::std::os::raw::c_int,
    pub indel: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_linear_penalties_t() {
    const UNINIT: ::std::mem::MaybeUninit<linear_penalties_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<linear_penalties_t>(),
        12usize,
        concat!("Size of: ", stringify!(linear_penalties_t))
    );
    assert_eq!(
        ::std::mem::align_of::<linear_penalties_t>(),
        4usize,
        concat!("Alignment of ", stringify!(linear_penalties_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).match_) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(linear_penalties_t),
            "::",
            stringify!(match_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mismatch) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(linear_penalties_t),
            "::",
            stringify!(mismatch)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).indel) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(linear_penalties_t),
            "::",
            stringify!(indel)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct affine_penalties_t {
    pub match_: ::std::os::raw::c_int,
    pub mismatch: ::std::os::raw::c_int,
    pub gap_opening: ::std::os::raw::c_int,
    pub gap_extension: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_affine_penalties_t() {
    const UNINIT: ::std::mem::MaybeUninit<affine_penalties_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<affine_penalties_t>(),
        16usize,
        concat!("Size of: ", stringify!(affine_penalties_t))
    );
    assert_eq!(
        ::std::mem::align_of::<affine_penalties_t>(),
        4usize,
        concat!("Alignment of ", stringify!(affine_penalties_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).match_) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(affine_penalties_t),
            "::",
            stringify!(match_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mismatch) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(affine_penalties_t),
            "::",
            stringify!(mismatch)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gap_opening) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(affine_penalties_t),
            "::",
            stringify!(gap_opening)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gap_extension) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(affine_penalties_t),
            "::",
            stringify!(gap_extension)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct affine2p_penalties_t {
    pub match_: ::std::os::raw::c_int,
    pub mismatch: ::std::os::raw::c_int,
    pub gap_opening1: ::std::os::raw::c_int,
    pub gap_extension1: ::std::os::raw::c_int,
    pub gap_opening2: ::std::os::raw::c_int,
    pub gap_extension2: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_affine2p_penalties_t() {
    const UNINIT: ::std::mem::MaybeUninit<affine2p_penalties_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<affine2p_penalties_t>(),
        24usize,
        concat!("Size of: ", stringify!(affine2p_penalties_t))
    );
    assert_eq!(
        ::std::mem::align_of::<affine2p_penalties_t>(),
        4usize,
        concat!("Alignment of ", stringify!(affine2p_penalties_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).match_) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(affine2p_penalties_t),
            "::",
            stringify!(match_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mismatch) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(affine2p_penalties_t),
            "::",
            stringify!(mismatch)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gap_opening1) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(affine2p_penalties_t),
            "::",
            stringify!(gap_opening1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gap_extension1) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(affine2p_penalties_t),
            "::",
            stringify!(gap_extension1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gap_opening2) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(affine2p_penalties_t),
            "::",
            stringify!(gap_opening2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gap_extension2) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(affine2p_penalties_t),
            "::",
            stringify!(gap_extension2)
        )
    );
}
pub const affine2p_matrix_type_affine2p_matrix_M: affine2p_matrix_type = 0;
pub const affine2p_matrix_type_affine2p_matrix_I1: affine2p_matrix_type = 1;
pub const affine2p_matrix_type_affine2p_matrix_I2: affine2p_matrix_type = 2;
pub const affine2p_matrix_type_affine2p_matrix_D1: affine2p_matrix_type = 3;
pub const affine2p_matrix_type_affine2p_matrix_D2: affine2p_matrix_type = 4;
pub type affine2p_matrix_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct cigar_t {
    pub operations: *mut ::std::os::raw::c_char,
    pub max_operations: ::std::os::raw::c_int,
    pub begin_offset: ::std::os::raw::c_int,
    pub end_offset: ::std::os::raw::c_int,
    pub score: ::std::os::raw::c_int,
    pub end_v: ::std::os::raw::c_int,
    pub end_h: ::std::os::raw::c_int,
    pub has_misms: bool,
    pub cigar_buffer: *mut u32,
    pub cigar_length: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_cigar_t() {
    const UNINIT: ::std::mem::MaybeUninit<cigar_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<cigar_t>(),
        56usize,
        concat!("Size of: ", stringify!(cigar_t))
    );
    assert_eq!(
        ::std::mem::align_of::<cigar_t>(),
        8usize,
        concat!("Alignment of ", stringify!(cigar_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).operations) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(cigar_t),
            "::",
            stringify!(operations)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_operations) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(cigar_t),
            "::",
            stringify!(max_operations)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).begin_offset) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(cigar_t),
            "::",
            stringify!(begin_offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).end_offset) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(cigar_t),
            "::",
            stringify!(end_offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).score) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(cigar_t),
            "::",
            stringify!(score)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).end_v) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(cigar_t),
            "::",
            stringify!(end_v)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).end_h) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(cigar_t),
            "::",
            stringify!(end_h)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).has_misms) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(cigar_t),
            "::",
            stringify!(has_misms)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cigar_buffer) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(cigar_t),
            "::",
            stringify!(cigar_buffer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cigar_length) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(cigar_t),
            "::",
            stringify!(cigar_length)
        )
    );
}
pub type wf_offset_t = i32;
pub const distance_metric_t_indel: distance_metric_t = 0;
pub const distance_metric_t_edit: distance_metric_t = 1;
pub const distance_metric_t_gap_linear: distance_metric_t = 2;
pub const distance_metric_t_gap_affine: distance_metric_t = 3;
pub const distance_metric_t_gap_affine_2p: distance_metric_t = 4;
pub type distance_metric_t = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct wavefront_penalties_t {
    pub distance_metric: distance_metric_t,
    pub match_: ::std::os::raw::c_int,
    pub mismatch: ::std::os::raw::c_int,
    pub gap_opening1: ::std::os::raw::c_int,
    pub gap_extension1: ::std::os::raw::c_int,
    pub gap_opening2: ::std::os::raw::c_int,
    pub gap_extension2: ::std::os::raw::c_int,
    pub linear_penalties: linear_penalties_t,
    pub affine_penalties: affine_penalties_t,
    pub affine2p_penalties: affine2p_penalties_t,
    pub internal_gap_e: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_wavefront_penalties_t() {
    const UNINIT: ::std::mem::MaybeUninit<wavefront_penalties_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<wavefront_penalties_t>(),
        84usize,
        concat!("Size of: ", stringify!(wavefront_penalties_t))
    );
    assert_eq!(
        ::std::mem::align_of::<wavefront_penalties_t>(),
        4usize,
        concat!("Alignment of ", stringify!(wavefront_penalties_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).distance_metric) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_penalties_t),
            "::",
            stringify!(distance_metric)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).match_) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_penalties_t),
            "::",
            stringify!(match_)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mismatch) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_penalties_t),
            "::",
            stringify!(mismatch)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gap_opening1) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_penalties_t),
            "::",
            stringify!(gap_opening1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gap_extension1) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_penalties_t),
            "::",
            stringify!(gap_extension1)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gap_opening2) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_penalties_t),
            "::",
            stringify!(gap_opening2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).gap_extension2) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_penalties_t),
            "::",
            stringify!(gap_extension2)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).linear_penalties) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_penalties_t),
            "::",
            stringify!(linear_penalties)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).affine_penalties) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_penalties_t),
            "::",
            stringify!(affine_penalties)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).affine2p_penalties) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_penalties_t),
            "::",
            stringify!(affine2p_penalties)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).internal_gap_e) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_penalties_t),
            "::",
            stringify!(internal_gap_e)
        )
    );
}
extern "C" {
    pub fn wavefront_penalties_set_indel(wf_penalties: *mut wavefront_penalties_t);
}
extern "C" {
    pub fn wavefront_penalties_set_edit(wf_penalties: *mut wavefront_penalties_t);
}
extern "C" {
    pub fn wavefront_penalties_set_linear(
        wf_penalties: *mut wavefront_penalties_t,
        linear_penalties: *mut linear_penalties_t,
    );
}
extern "C" {
    pub fn wavefront_penalties_set_affine(
        wf_penalties: *mut wavefront_penalties_t,
        affine_penalties: *mut affine_penalties_t,
    );
}
extern "C" {
    pub fn wavefront_penalties_set_affine2p(
        wf_penalties: *mut wavefront_penalties_t,
        affine2p_penalties: *mut affine2p_penalties_t,
    );
}
extern "C" {
    pub fn wavefront_penalties_print(stream: *mut FILE, wf_penalties: *mut wavefront_penalties_t);
}
pub type wavefront_aligner_t = _wavefront_aligner_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct wavefront_plot_attr_t {
    pub enabled: bool,
    pub resolution_points: ::std::os::raw::c_int,
    pub align_level: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_wavefront_plot_attr_t() {
    const UNINIT: ::std::mem::MaybeUninit<wavefront_plot_attr_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<wavefront_plot_attr_t>(),
        12usize,
        concat!("Size of: ", stringify!(wavefront_plot_attr_t))
    );
    assert_eq!(
        ::std::mem::align_of::<wavefront_plot_attr_t>(),
        4usize,
        concat!("Alignment of ", stringify!(wavefront_plot_attr_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).enabled) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_plot_attr_t),
            "::",
            stringify!(enabled)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).resolution_points) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_plot_attr_t),
            "::",
            stringify!(resolution_points)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).align_level) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_plot_attr_t),
            "::",
            stringify!(align_level)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct wavefront_plot_t {
    pub attributes: wavefront_plot_attr_t,
    pub distance_metric: distance_metric_t,
    pub min_v: ::std::os::raw::c_int,
    pub max_v: ::std::os::raw::c_int,
    pub min_h: ::std::os::raw::c_int,
    pub max_h: ::std::os::raw::c_int,
    pub m_heatmap: *mut heatmap_t,
    pub i1_heatmap: *mut heatmap_t,
    pub d1_heatmap: *mut heatmap_t,
    pub i2_heatmap: *mut heatmap_t,
    pub d2_heatmap: *mut heatmap_t,
    pub behavior_heatmap: *mut heatmap_t,
}
#[test]
fn bindgen_test_layout_wavefront_plot_t() {
    const UNINIT: ::std::mem::MaybeUninit<wavefront_plot_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<wavefront_plot_t>(),
        80usize,
        concat!("Size of: ", stringify!(wavefront_plot_t))
    );
    assert_eq!(
        ::std::mem::align_of::<wavefront_plot_t>(),
        8usize,
        concat!("Alignment of ", stringify!(wavefront_plot_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).attributes) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_plot_t),
            "::",
            stringify!(attributes)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).distance_metric) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_plot_t),
            "::",
            stringify!(distance_metric)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).min_v) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_plot_t),
            "::",
            stringify!(min_v)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_v) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_plot_t),
            "::",
            stringify!(max_v)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).min_h) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_plot_t),
            "::",
            stringify!(min_h)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_h) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_plot_t),
            "::",
            stringify!(max_h)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m_heatmap) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_plot_t),
            "::",
            stringify!(m_heatmap)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).i1_heatmap) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_plot_t),
            "::",
            stringify!(i1_heatmap)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).d1_heatmap) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_plot_t),
            "::",
            stringify!(d1_heatmap)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).i2_heatmap) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_plot_t),
            "::",
            stringify!(i2_heatmap)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).d2_heatmap) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_plot_t),
            "::",
            stringify!(d2_heatmap)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).behavior_heatmap) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_plot_t),
            "::",
            stringify!(behavior_heatmap)
        )
    );
}
extern "C" {
    pub fn wavefront_plot_new(
        distance_metric: distance_metric_t,
        pattern_length: ::std::os::raw::c_int,
        text_length: ::std::os::raw::c_int,
        attributes: *mut wavefront_plot_attr_t,
    ) -> *mut wavefront_plot_t;
}
extern "C" {
    pub fn wavefront_plot_resize(
        wf_plot: *mut wavefront_plot_t,
        pattern_length: ::std::os::raw::c_int,
        text_length: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_plot_delete(wf_plot: *mut wavefront_plot_t);
}
extern "C" {
    pub fn wavefront_plot(
        wf_aligner: *mut wavefront_aligner_t,
        score: ::std::os::raw::c_int,
        align_level: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_plot_print(stream: *mut FILE, wf_aligner: *mut wavefront_aligner_t);
}
extern "C" {
    pub fn wavefront_aligner_print(
        stream: *mut FILE,
        wf_aligner: *mut wavefront_aligner_t,
        score_begin: ::std::os::raw::c_int,
        score_end: ::std::os::raw::c_int,
        num_wfs_per_row: ::std::os::raw::c_int,
        backtrace_length: ::std::os::raw::c_int,
    );
}
pub const wf_heuristic_strategy_wf_heuristic_none: wf_heuristic_strategy = 0;
pub const wf_heuristic_strategy_wf_heuristic_banded_static: wf_heuristic_strategy = 1;
pub const wf_heuristic_strategy_wf_heuristic_banded_adaptive: wf_heuristic_strategy = 2;
pub const wf_heuristic_strategy_wf_heuristic_wfadaptive: wf_heuristic_strategy = 4;
pub const wf_heuristic_strategy_wf_heuristic_xdrop: wf_heuristic_strategy = 16;
pub const wf_heuristic_strategy_wf_heuristic_zdrop: wf_heuristic_strategy = 32;
pub const wf_heuristic_strategy_wf_heuristic_wfmash: wf_heuristic_strategy = 64;
pub type wf_heuristic_strategy = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct wavefront_heuristic_t {
    pub strategy: wf_heuristic_strategy,
    pub steps_between_cutoffs: ::std::os::raw::c_int,
    pub min_k: ::std::os::raw::c_int,
    pub max_k: ::std::os::raw::c_int,
    pub min_wavefront_length: ::std::os::raw::c_int,
    pub max_distance_threshold: ::std::os::raw::c_int,
    pub xdrop: ::std::os::raw::c_int,
    pub zdrop: ::std::os::raw::c_int,
    pub steps_wait: ::std::os::raw::c_int,
    pub max_sw_score: ::std::os::raw::c_int,
    pub max_wf_score: ::std::os::raw::c_int,
    pub max_sw_score_offset: ::std::os::raw::c_int,
    pub max_sw_score_k: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_wavefront_heuristic_t() {
    const UNINIT: ::std::mem::MaybeUninit<wavefront_heuristic_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<wavefront_heuristic_t>(),
        52usize,
        concat!("Size of: ", stringify!(wavefront_heuristic_t))
    );
    assert_eq!(
        ::std::mem::align_of::<wavefront_heuristic_t>(),
        4usize,
        concat!("Alignment of ", stringify!(wavefront_heuristic_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).strategy) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_heuristic_t),
            "::",
            stringify!(strategy)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).steps_between_cutoffs) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_heuristic_t),
            "::",
            stringify!(steps_between_cutoffs)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).min_k) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_heuristic_t),
            "::",
            stringify!(min_k)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_k) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_heuristic_t),
            "::",
            stringify!(max_k)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).min_wavefront_length) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_heuristic_t),
            "::",
            stringify!(min_wavefront_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_distance_threshold) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_heuristic_t),
            "::",
            stringify!(max_distance_threshold)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).xdrop) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_heuristic_t),
            "::",
            stringify!(xdrop)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).zdrop) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_heuristic_t),
            "::",
            stringify!(zdrop)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).steps_wait) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_heuristic_t),
            "::",
            stringify!(steps_wait)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_sw_score) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_heuristic_t),
            "::",
            stringify!(max_sw_score)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_wf_score) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_heuristic_t),
            "::",
            stringify!(max_wf_score)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_sw_score_offset) as usize - ptr as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_heuristic_t),
            "::",
            stringify!(max_sw_score_offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_sw_score_k) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_heuristic_t),
            "::",
            stringify!(max_sw_score_k)
        )
    );
}
extern "C" {
    pub fn wavefront_heuristic_set_none(wf_heuristic: *mut wavefront_heuristic_t);
}
extern "C" {
    pub fn wavefront_heuristic_set_wfadaptive(
        wf_heuristic: *mut wavefront_heuristic_t,
        min_wavefront_length: ::std::os::raw::c_int,
        max_distance_threshold: ::std::os::raw::c_int,
        steps_between_cutoffs: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_heuristic_set_wfmash(
        wf_heuristic: *mut wavefront_heuristic_t,
        min_wavefront_length: ::std::os::raw::c_int,
        max_distance_threshold: ::std::os::raw::c_int,
        steps_between_cutoffs: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_heuristic_set_xdrop(
        wf_heuristic: *mut wavefront_heuristic_t,
        xdrop: ::std::os::raw::c_int,
        steps_between_cutoffs: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_heuristic_set_zdrop(
        wf_heuristic: *mut wavefront_heuristic_t,
        ydrop: ::std::os::raw::c_int,
        steps_between_cutoffs: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_heuristic_set_banded_static(
        wf_heuristic: *mut wavefront_heuristic_t,
        band_min_k: ::std::os::raw::c_int,
        band_max_k: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_heuristic_set_banded_adaptive(
        wf_heuristic: *mut wavefront_heuristic_t,
        band_min_k: ::std::os::raw::c_int,
        band_max_k: ::std::os::raw::c_int,
        steps_between_cutoffs: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_heuristic_clear(wf_heuristic: *mut wavefront_heuristic_t);
}
extern "C" {
    pub fn wavefront_heuristic_cufoff(
        wf_aligner: *mut wavefront_aligner_t,
        score: ::std::os::raw::c_int,
        score_mod: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    pub fn wavefront_heuristic_print(stream: *mut FILE, wf_heuristic: *mut wavefront_heuristic_t);
}
pub const alignment_scope_t_compute_score: alignment_scope_t = 0;
pub const alignment_scope_t_compute_alignment: alignment_scope_t = 1;
pub type alignment_scope_t = ::std::os::raw::c_uint;
pub const alignment_span_t_alignment_end2end: alignment_span_t = 0;
pub const alignment_span_t_alignment_endsfree: alignment_span_t = 1;
pub type alignment_span_t = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct alignment_form_t {
    pub span: alignment_span_t,
    pub extension: bool,
    pub pattern_begin_free: ::std::os::raw::c_int,
    pub pattern_end_free: ::std::os::raw::c_int,
    pub text_begin_free: ::std::os::raw::c_int,
    pub text_end_free: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_alignment_form_t() {
    const UNINIT: ::std::mem::MaybeUninit<alignment_form_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<alignment_form_t>(),
        24usize,
        concat!("Size of: ", stringify!(alignment_form_t))
    );
    assert_eq!(
        ::std::mem::align_of::<alignment_form_t>(),
        4usize,
        concat!("Alignment of ", stringify!(alignment_form_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).span) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(alignment_form_t),
            "::",
            stringify!(span)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).extension) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(alignment_form_t),
            "::",
            stringify!(extension)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pattern_begin_free) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(alignment_form_t),
            "::",
            stringify!(pattern_begin_free)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pattern_end_free) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(alignment_form_t),
            "::",
            stringify!(pattern_end_free)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).text_begin_free) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(alignment_form_t),
            "::",
            stringify!(text_begin_free)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).text_end_free) as usize - ptr as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(alignment_form_t),
            "::",
            stringify!(text_end_free)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct alignment_system_t {
    pub max_alignment_steps: ::std::os::raw::c_int,
    pub probe_interval_global: ::std::os::raw::c_int,
    pub probe_interval_compact: ::std::os::raw::c_int,
    pub max_partial_compacts: u64,
    pub max_memory_compact: u64,
    pub max_memory_resident: u64,
    pub max_memory_abort: u64,
    pub verbose: ::std::os::raw::c_int,
    pub check_alignment_correct: bool,
    pub timer: profiler_timer_t,
    pub max_num_threads: ::std::os::raw::c_int,
    pub min_offsets_per_thread: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_alignment_system_t() {
    const UNINIT: ::std::mem::MaybeUninit<alignment_system_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<alignment_system_t>(),
        152usize,
        concat!("Size of: ", stringify!(alignment_system_t))
    );
    assert_eq!(
        ::std::mem::align_of::<alignment_system_t>(),
        8usize,
        concat!("Alignment of ", stringify!(alignment_system_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_alignment_steps) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(alignment_system_t),
            "::",
            stringify!(max_alignment_steps)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).probe_interval_global) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(alignment_system_t),
            "::",
            stringify!(probe_interval_global)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).probe_interval_compact) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(alignment_system_t),
            "::",
            stringify!(probe_interval_compact)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_partial_compacts) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(alignment_system_t),
            "::",
            stringify!(max_partial_compacts)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_memory_compact) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(alignment_system_t),
            "::",
            stringify!(max_memory_compact)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_memory_resident) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(alignment_system_t),
            "::",
            stringify!(max_memory_resident)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_memory_abort) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(alignment_system_t),
            "::",
            stringify!(max_memory_abort)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).verbose) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(alignment_system_t),
            "::",
            stringify!(verbose)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).check_alignment_correct) as usize - ptr as usize },
        52usize,
        concat!(
            "Offset of field: ",
            stringify!(alignment_system_t),
            "::",
            stringify!(check_alignment_correct)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).timer) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(alignment_system_t),
            "::",
            stringify!(timer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_num_threads) as usize - ptr as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(alignment_system_t),
            "::",
            stringify!(max_num_threads)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).min_offsets_per_thread) as usize - ptr as usize },
        148usize,
        concat!(
            "Offset of field: ",
            stringify!(alignment_system_t),
            "::",
            stringify!(min_offsets_per_thread)
        )
    );
}
pub const wavefront_memory_t_wavefront_memory_high: wavefront_memory_t = 0;
pub const wavefront_memory_t_wavefront_memory_med: wavefront_memory_t = 1;
pub const wavefront_memory_t_wavefront_memory_low: wavefront_memory_t = 2;
pub const wavefront_memory_t_wavefront_memory_ultralow: wavefront_memory_t = 3;
pub type wavefront_memory_t = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct wavefront_aligner_attr_t {
    pub distance_metric: distance_metric_t,
    pub alignment_scope: alignment_scope_t,
    pub alignment_form: alignment_form_t,
    pub linear_penalties: linear_penalties_t,
    pub affine_penalties: affine_penalties_t,
    pub affine2p_penalties: affine2p_penalties_t,
    pub heuristic: wavefront_heuristic_t,
    pub memory_mode: wavefront_memory_t,
    pub mm_allocator: *mut mm_allocator_t,
    pub plot: wavefront_plot_attr_t,
    pub system: alignment_system_t,
}
#[test]
fn bindgen_test_layout_wavefront_aligner_attr_t() {
    const UNINIT: ::std::mem::MaybeUninit<wavefront_aligner_attr_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<wavefront_aligner_attr_t>(),
        320usize,
        concat!("Size of: ", stringify!(wavefront_aligner_attr_t))
    );
    assert_eq!(
        ::std::mem::align_of::<wavefront_aligner_attr_t>(),
        8usize,
        concat!("Alignment of ", stringify!(wavefront_aligner_attr_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).distance_metric) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_aligner_attr_t),
            "::",
            stringify!(distance_metric)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).alignment_scope) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_aligner_attr_t),
            "::",
            stringify!(alignment_scope)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).alignment_form) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_aligner_attr_t),
            "::",
            stringify!(alignment_form)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).linear_penalties) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_aligner_attr_t),
            "::",
            stringify!(linear_penalties)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).affine_penalties) as usize - ptr as usize },
        44usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_aligner_attr_t),
            "::",
            stringify!(affine_penalties)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).affine2p_penalties) as usize - ptr as usize },
        60usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_aligner_attr_t),
            "::",
            stringify!(affine2p_penalties)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).heuristic) as usize - ptr as usize },
        84usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_aligner_attr_t),
            "::",
            stringify!(heuristic)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).memory_mode) as usize - ptr as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_aligner_attr_t),
            "::",
            stringify!(memory_mode)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mm_allocator) as usize - ptr as usize },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_aligner_attr_t),
            "::",
            stringify!(mm_allocator)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).plot) as usize - ptr as usize },
        152usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_aligner_attr_t),
            "::",
            stringify!(plot)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).system) as usize - ptr as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_aligner_attr_t),
            "::",
            stringify!(system)
        )
    );
}
extern "C" {
    pub static mut wavefront_aligner_attr_default: wavefront_aligner_attr_t;
}
pub type alignment_match_funct_t = ::std::option::Option<
    unsafe extern "C" fn(
        arg1: ::std::os::raw::c_int,
        arg2: ::std::os::raw::c_int,
        arg3: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int,
>;
pub const wf_sequences_mode_t_wf_sequences_ascii: wf_sequences_mode_t = 0;
pub const wf_sequences_mode_t_wf_sequences_lambda: wf_sequences_mode_t = 1;
pub const wf_sequences_mode_t_wf_sequences_packed2bits: wf_sequences_mode_t = 2;
pub type wf_sequences_mode_t = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct wavefront_sequences_t {
    pub mode: wf_sequences_mode_t,
    pub reverse: bool,
    pub pattern: *mut ::std::os::raw::c_char,
    pub text: *mut ::std::os::raw::c_char,
    pub pattern_begin: ::std::os::raw::c_int,
    pub pattern_length: ::std::os::raw::c_int,
    pub text_begin: ::std::os::raw::c_int,
    pub text_length: ::std::os::raw::c_int,
    pub match_funct: alignment_match_funct_t,
    pub match_funct_arguments: *mut ::std::os::raw::c_void,
    pub seq_buffer: *mut ::std::os::raw::c_char,
    pub seq_buffer_allocated: ::std::os::raw::c_int,
    pub pattern_buffer: *mut ::std::os::raw::c_char,
    pub text_buffer: *mut ::std::os::raw::c_char,
    pub pattern_buffer_length: ::std::os::raw::c_int,
    pub text_buffer_length: ::std::os::raw::c_int,
    pub pattern_eos: ::std::os::raw::c_char,
    pub text_eos: ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_wavefront_sequences_t() {
    const UNINIT: ::std::mem::MaybeUninit<wavefront_sequences_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<wavefront_sequences_t>(),
        104usize,
        concat!("Size of: ", stringify!(wavefront_sequences_t))
    );
    assert_eq!(
        ::std::mem::align_of::<wavefront_sequences_t>(),
        8usize,
        concat!("Alignment of ", stringify!(wavefront_sequences_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_sequences_t),
            "::",
            stringify!(mode)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).reverse) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_sequences_t),
            "::",
            stringify!(reverse)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pattern) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_sequences_t),
            "::",
            stringify!(pattern)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).text) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_sequences_t),
            "::",
            stringify!(text)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pattern_begin) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_sequences_t),
            "::",
            stringify!(pattern_begin)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pattern_length) as usize - ptr as usize },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_sequences_t),
            "::",
            stringify!(pattern_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).text_begin) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_sequences_t),
            "::",
            stringify!(text_begin)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).text_length) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_sequences_t),
            "::",
            stringify!(text_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).match_funct) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_sequences_t),
            "::",
            stringify!(match_funct)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).match_funct_arguments) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_sequences_t),
            "::",
            stringify!(match_funct_arguments)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).seq_buffer) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_sequences_t),
            "::",
            stringify!(seq_buffer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).seq_buffer_allocated) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_sequences_t),
            "::",
            stringify!(seq_buffer_allocated)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pattern_buffer) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_sequences_t),
            "::",
            stringify!(pattern_buffer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).text_buffer) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_sequences_t),
            "::",
            stringify!(text_buffer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pattern_buffer_length) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_sequences_t),
            "::",
            stringify!(pattern_buffer_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).text_buffer_length) as usize - ptr as usize },
        92usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_sequences_t),
            "::",
            stringify!(text_buffer_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pattern_eos) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_sequences_t),
            "::",
            stringify!(pattern_eos)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).text_eos) as usize - ptr as usize },
        97usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_sequences_t),
            "::",
            stringify!(text_eos)
        )
    );
}
extern "C" {
    pub fn wavefront_sequences_allocate(wf_sequences: *mut wavefront_sequences_t);
}
extern "C" {
    pub fn wavefront_sequences_free(wf_sequences: *mut wavefront_sequences_t);
}
extern "C" {
    pub fn wavefront_sequences_init_ascii(
        wf_sequences: *mut wavefront_sequences_t,
        pattern: *const ::std::os::raw::c_char,
        pattern_length: ::std::os::raw::c_int,
        text: *const ::std::os::raw::c_char,
        text_length: ::std::os::raw::c_int,
        reverse: bool,
    );
}
extern "C" {
    pub fn wavefront_sequences_init_lambda(
        wf_sequences: *mut wavefront_sequences_t,
        match_funct: alignment_match_funct_t,
        match_funct_arguments: *mut ::std::os::raw::c_void,
        pattern_length: ::std::os::raw::c_int,
        text_length: ::std::os::raw::c_int,
        reverse: bool,
    );
}
extern "C" {
    pub fn wavefront_sequences_init_packed2bits(
        wf_sequences: *mut wavefront_sequences_t,
        pattern: *const u8,
        pattern_length: ::std::os::raw::c_int,
        text: *const u8,
        text_length: ::std::os::raw::c_int,
        reverse: bool,
    );
}
extern "C" {
    pub fn wavefront_sequences_cmp(
        wf_sequences: *mut wavefront_sequences_t,
        pattern_pos: ::std::os::raw::c_int,
        text_pos: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    pub fn wavefront_sequences_get_pattern(
        wf_sequences: *mut wavefront_sequences_t,
        position: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_char;
}
extern "C" {
    pub fn wavefront_sequences_get_text(
        wf_sequences: *mut wavefront_sequences_t,
        position: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_char;
}
extern "C" {
    pub fn wavefront_sequences_set_bounds(
        wf_sequences: *mut wavefront_sequences_t,
        pattern_begin: ::std::os::raw::c_int,
        pattern_end: ::std::os::raw::c_int,
        text_begin: ::std::os::raw::c_int,
        text_end: ::std::os::raw::c_int,
    );
}
pub type pcigar_t = u32;
pub type bt_block_idx_t = u32;
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct bt_block_t {
    pub pcigar: pcigar_t,
    pub prev_idx: bt_block_idx_t,
}
#[test]
fn bindgen_test_layout_bt_block_t() {
    const UNINIT: ::std::mem::MaybeUninit<bt_block_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<bt_block_t>(),
        8usize,
        concat!("Size of: ", stringify!(bt_block_t))
    );
    assert_eq!(
        ::std::mem::align_of::<bt_block_t>(),
        1usize,
        concat!("Alignment of ", stringify!(bt_block_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pcigar) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(bt_block_t),
            "::",
            stringify!(pcigar)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).prev_idx) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(bt_block_t),
            "::",
            stringify!(prev_idx)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct wf_backtrace_buffer_t {
    pub segment_idx: ::std::os::raw::c_int,
    pub segment_offset: ::std::os::raw::c_int,
    pub block_next: *mut bt_block_t,
    pub segments: *mut vector_t,
    pub alignment_init_pos: *mut vector_t,
    pub num_compacted_blocks: bt_block_idx_t,
    pub num_compactions: ::std::os::raw::c_int,
    pub alignment_packed: *mut vector_t,
    pub prefetch_blocks_idxs: *mut vector_t,
    pub mm_allocator: *mut mm_allocator_t,
}
#[test]
fn bindgen_test_layout_wf_backtrace_buffer_t() {
    const UNINIT: ::std::mem::MaybeUninit<wf_backtrace_buffer_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<wf_backtrace_buffer_t>(),
        64usize,
        concat!("Size of: ", stringify!(wf_backtrace_buffer_t))
    );
    assert_eq!(
        ::std::mem::align_of::<wf_backtrace_buffer_t>(),
        8usize,
        concat!("Alignment of ", stringify!(wf_backtrace_buffer_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).segment_idx) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(wf_backtrace_buffer_t),
            "::",
            stringify!(segment_idx)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).segment_offset) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(wf_backtrace_buffer_t),
            "::",
            stringify!(segment_offset)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).block_next) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(wf_backtrace_buffer_t),
            "::",
            stringify!(block_next)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).segments) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(wf_backtrace_buffer_t),
            "::",
            stringify!(segments)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).alignment_init_pos) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(wf_backtrace_buffer_t),
            "::",
            stringify!(alignment_init_pos)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_compacted_blocks) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(wf_backtrace_buffer_t),
            "::",
            stringify!(num_compacted_blocks)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_compactions) as usize - ptr as usize },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(wf_backtrace_buffer_t),
            "::",
            stringify!(num_compactions)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).alignment_packed) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(wf_backtrace_buffer_t),
            "::",
            stringify!(alignment_packed)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).prefetch_blocks_idxs) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(wf_backtrace_buffer_t),
            "::",
            stringify!(prefetch_blocks_idxs)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mm_allocator) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(wf_backtrace_buffer_t),
            "::",
            stringify!(mm_allocator)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct wavefront_pos_t {
    pub score: ::std::os::raw::c_int,
    pub k: ::std::os::raw::c_int,
    pub offset: wf_offset_t,
}
#[test]
fn bindgen_test_layout_wavefront_pos_t() {
    const UNINIT: ::std::mem::MaybeUninit<wavefront_pos_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<wavefront_pos_t>(),
        12usize,
        concat!("Size of: ", stringify!(wavefront_pos_t))
    );
    assert_eq!(
        ::std::mem::align_of::<wavefront_pos_t>(),
        4usize,
        concat!("Alignment of ", stringify!(wavefront_pos_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).score) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_pos_t),
            "::",
            stringify!(score)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).k) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_pos_t),
            "::",
            stringify!(k)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_pos_t),
            "::",
            stringify!(offset)
        )
    );
}
pub const wavefront_status_type_wavefront_status_free: wavefront_status_type = 0;
pub const wavefront_status_type_wavefront_status_busy: wavefront_status_type = 1;
pub const wavefront_status_type_wavefront_status_deallocated: wavefront_status_type = 2;
pub type wavefront_status_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct wavefront_t {
    pub null: bool,
    pub lo: ::std::os::raw::c_int,
    pub hi: ::std::os::raw::c_int,
    pub offsets: *mut wf_offset_t,
    pub offsets_mem: *mut wf_offset_t,
    pub bt_occupancy_max: ::std::os::raw::c_int,
    pub bt_pcigar: *mut pcigar_t,
    pub bt_prev: *mut bt_block_idx_t,
    pub bt_pcigar_mem: *mut pcigar_t,
    pub bt_prev_mem: *mut bt_block_idx_t,
    pub status: wavefront_status_type,
    pub wf_elements_allocated: ::std::os::raw::c_int,
    pub wf_elements_allocated_min: ::std::os::raw::c_int,
    pub wf_elements_allocated_max: ::std::os::raw::c_int,
    pub wf_elements_init_min: ::std::os::raw::c_int,
    pub wf_elements_init_max: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_wavefront_t() {
    const UNINIT: ::std::mem::MaybeUninit<wavefront_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<wavefront_t>(),
        96usize,
        concat!("Size of: ", stringify!(wavefront_t))
    );
    assert_eq!(
        ::std::mem::align_of::<wavefront_t>(),
        8usize,
        concat!("Alignment of ", stringify!(wavefront_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).null) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_t),
            "::",
            stringify!(null)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).lo) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_t),
            "::",
            stringify!(lo)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).hi) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_t),
            "::",
            stringify!(hi)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).offsets) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_t),
            "::",
            stringify!(offsets)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).offsets_mem) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_t),
            "::",
            stringify!(offsets_mem)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bt_occupancy_max) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_t),
            "::",
            stringify!(bt_occupancy_max)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bt_pcigar) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_t),
            "::",
            stringify!(bt_pcigar)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bt_prev) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_t),
            "::",
            stringify!(bt_prev)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bt_pcigar_mem) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_t),
            "::",
            stringify!(bt_pcigar_mem)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bt_prev_mem) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_t),
            "::",
            stringify!(bt_prev_mem)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_t),
            "::",
            stringify!(status)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wf_elements_allocated) as usize - ptr as usize },
        76usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_t),
            "::",
            stringify!(wf_elements_allocated)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wf_elements_allocated_min) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_t),
            "::",
            stringify!(wf_elements_allocated_min)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wf_elements_allocated_max) as usize - ptr as usize },
        84usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_t),
            "::",
            stringify!(wf_elements_allocated_max)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wf_elements_init_min) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_t),
            "::",
            stringify!(wf_elements_init_min)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wf_elements_init_max) as usize - ptr as usize },
        92usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_t),
            "::",
            stringify!(wf_elements_init_max)
        )
    );
}
extern "C" {
    pub fn wavefront_allocate(
        wavefront: *mut wavefront_t,
        wf_elements_allocated: ::std::os::raw::c_int,
        allocate_backtrace: bool,
        mm_allocator: *mut mm_allocator_t,
    );
}
extern "C" {
    pub fn wavefront_resize(
        wavefront: *mut wavefront_t,
        wf_elements_allocated: ::std::os::raw::c_int,
        mm_allocator: *mut mm_allocator_t,
    );
}
extern "C" {
    pub fn wavefront_free(wavefront: *mut wavefront_t, mm_allocator: *mut mm_allocator_t);
}
extern "C" {
    pub fn wavefront_init(
        wavefront: *mut wavefront_t,
        min_lo: ::std::os::raw::c_int,
        max_hi: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_init_null(
        wavefront: *mut wavefront_t,
        min_lo: ::std::os::raw::c_int,
        max_hi: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_init_victim(
        wavefront: *mut wavefront_t,
        min_lo: ::std::os::raw::c_int,
        max_hi: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_set_limits(
        wavefront: *mut wavefront_t,
        lo: ::std::os::raw::c_int,
        hi: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_get_size(wavefront: *mut wavefront_t) -> u64;
}
pub const wf_slab_mode_t_wf_slab_reuse: wf_slab_mode_t = 1;
pub const wf_slab_mode_t_wf_slab_tight: wf_slab_mode_t = 2;
pub type wf_slab_mode_t = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct wavefront_slab_t {
    pub allocate_backtrace: bool,
    pub slab_mode: wf_slab_mode_t,
    pub init_wf_length: ::std::os::raw::c_int,
    pub current_wf_length: ::std::os::raw::c_int,
    pub wavefronts: *mut vector_t,
    pub wavefronts_free: *mut vector_t,
    pub memory_used: u64,
    pub mm_allocator: *mut mm_allocator_t,
}
#[test]
fn bindgen_test_layout_wavefront_slab_t() {
    const UNINIT: ::std::mem::MaybeUninit<wavefront_slab_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<wavefront_slab_t>(),
        48usize,
        concat!("Size of: ", stringify!(wavefront_slab_t))
    );
    assert_eq!(
        ::std::mem::align_of::<wavefront_slab_t>(),
        8usize,
        concat!("Alignment of ", stringify!(wavefront_slab_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).allocate_backtrace) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_slab_t),
            "::",
            stringify!(allocate_backtrace)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).slab_mode) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_slab_t),
            "::",
            stringify!(slab_mode)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).init_wf_length) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_slab_t),
            "::",
            stringify!(init_wf_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).current_wf_length) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_slab_t),
            "::",
            stringify!(current_wf_length)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wavefronts) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_slab_t),
            "::",
            stringify!(wavefronts)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wavefronts_free) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_slab_t),
            "::",
            stringify!(wavefronts_free)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).memory_used) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_slab_t),
            "::",
            stringify!(memory_used)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mm_allocator) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_slab_t),
            "::",
            stringify!(mm_allocator)
        )
    );
}
extern "C" {
    pub fn wavefront_slab_new(
        init_wf_length: ::std::os::raw::c_int,
        allocate_backtrace: bool,
        slab_mode: wf_slab_mode_t,
        mm_allocator: *mut mm_allocator_t,
    ) -> *mut wavefront_slab_t;
}
extern "C" {
    pub fn wavefront_slab_reap(wavefront_slab: *mut wavefront_slab_t);
}
extern "C" {
    pub fn wavefront_slab_clear(wavefront_slab: *mut wavefront_slab_t);
}
extern "C" {
    pub fn wavefront_slab_delete(wavefront_slab: *mut wavefront_slab_t);
}
extern "C" {
    pub fn wavefront_slab_set_mode(
        wavefront_slab: *mut wavefront_slab_t,
        slab_mode: wf_slab_mode_t,
    );
}
extern "C" {
    pub fn wavefront_slab_allocate(
        wavefront_slab: *mut wavefront_slab_t,
        min_lo: ::std::os::raw::c_int,
        max_hi: ::std::os::raw::c_int,
    ) -> *mut wavefront_t;
}
extern "C" {
    pub fn wavefront_slab_free(wavefront_slab: *mut wavefront_slab_t, wavefront: *mut wavefront_t);
}
extern "C" {
    pub fn wavefront_slab_get_size(wavefront_slab: *mut wavefront_slab_t) -> u64;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct wavefront_components_t {
    pub memory_modular: bool,
    pub bt_piggyback: bool,
    pub num_wavefronts: ::std::os::raw::c_int,
    pub max_score_scope: ::std::os::raw::c_int,
    pub historic_max_hi: ::std::os::raw::c_int,
    pub historic_min_lo: ::std::os::raw::c_int,
    pub mwavefronts: *mut *mut wavefront_t,
    pub i1wavefronts: *mut *mut wavefront_t,
    pub i2wavefronts: *mut *mut wavefront_t,
    pub d1wavefronts: *mut *mut wavefront_t,
    pub d2wavefronts: *mut *mut wavefront_t,
    pub wavefront_null: *mut wavefront_t,
    pub wavefront_victim: *mut wavefront_t,
    pub bt_buffer: *mut wf_backtrace_buffer_t,
    pub mm_allocator: *mut mm_allocator_t,
}
#[test]
fn bindgen_test_layout_wavefront_components_t() {
    const UNINIT: ::std::mem::MaybeUninit<wavefront_components_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<wavefront_components_t>(),
        96usize,
        concat!("Size of: ", stringify!(wavefront_components_t))
    );
    assert_eq!(
        ::std::mem::align_of::<wavefront_components_t>(),
        8usize,
        concat!("Alignment of ", stringify!(wavefront_components_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).memory_modular) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_components_t),
            "::",
            stringify!(memory_modular)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bt_piggyback) as usize - ptr as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_components_t),
            "::",
            stringify!(bt_piggyback)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_wavefronts) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_components_t),
            "::",
            stringify!(num_wavefronts)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).max_score_scope) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_components_t),
            "::",
            stringify!(max_score_scope)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).historic_max_hi) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_components_t),
            "::",
            stringify!(historic_max_hi)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).historic_min_lo) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_components_t),
            "::",
            stringify!(historic_min_lo)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mwavefronts) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_components_t),
            "::",
            stringify!(mwavefronts)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).i1wavefronts) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_components_t),
            "::",
            stringify!(i1wavefronts)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).i2wavefronts) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_components_t),
            "::",
            stringify!(i2wavefronts)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).d1wavefronts) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_components_t),
            "::",
            stringify!(d1wavefronts)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).d2wavefronts) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_components_t),
            "::",
            stringify!(d2wavefronts)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wavefront_null) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_components_t),
            "::",
            stringify!(wavefront_null)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wavefront_victim) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_components_t),
            "::",
            stringify!(wavefront_victim)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bt_buffer) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_components_t),
            "::",
            stringify!(bt_buffer)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mm_allocator) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_components_t),
            "::",
            stringify!(mm_allocator)
        )
    );
}
extern "C" {
    pub fn wavefront_components_allocate(
        wf_components: *mut wavefront_components_t,
        max_pattern_length: ::std::os::raw::c_int,
        max_text_length: ::std::os::raw::c_int,
        penalties: *mut wavefront_penalties_t,
        memory_modular: bool,
        bt_piggyback: bool,
        mm_allocator: *mut mm_allocator_t,
    );
}
extern "C" {
    pub fn wavefront_components_reap(wf_components: *mut wavefront_components_t);
}
extern "C" {
    pub fn wavefront_components_clear(wf_components: *mut wavefront_components_t);
}
extern "C" {
    pub fn wavefront_components_free(wf_components: *mut wavefront_components_t);
}
extern "C" {
    pub fn wavefront_components_resize(
        wf_components: *mut wavefront_components_t,
        max_pattern_length: ::std::os::raw::c_int,
        max_text_length: ::std::os::raw::c_int,
        penalties: *mut wavefront_penalties_t,
    );
}
extern "C" {
    pub fn wavefront_components_resize_null__victim(
        wf_components: *mut wavefront_components_t,
        lo: ::std::os::raw::c_int,
        hi: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_components_compact_bt_buffer(
        wf_components: *mut wavefront_components_t,
        score: ::std::os::raw::c_int,
        verbose: ::std::os::raw::c_int,
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct wavefront_bialigner_t {
    pub wf_forward: *mut wavefront_aligner_t,
    pub wf_reverse: *mut wavefront_aligner_t,
    pub wf_base: *mut wavefront_aligner_t,
    pub wf_align_compute: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut wavefront_aligner_t, arg2: ::std::os::raw::c_int),
    >,
}
#[test]
fn bindgen_test_layout_wavefront_bialigner_t() {
    const UNINIT: ::std::mem::MaybeUninit<wavefront_bialigner_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<wavefront_bialigner_t>(),
        32usize,
        concat!("Size of: ", stringify!(wavefront_bialigner_t))
    );
    assert_eq!(
        ::std::mem::align_of::<wavefront_bialigner_t>(),
        8usize,
        concat!("Alignment of ", stringify!(wavefront_bialigner_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wf_forward) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_bialigner_t),
            "::",
            stringify!(wf_forward)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wf_reverse) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_bialigner_t),
            "::",
            stringify!(wf_reverse)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wf_base) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_bialigner_t),
            "::",
            stringify!(wf_base)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wf_align_compute) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_bialigner_t),
            "::",
            stringify!(wf_align_compute)
        )
    );
}
extern "C" {
    pub fn wavefront_bialigner_new(
        attributes: *mut wavefront_aligner_attr_t,
        plot: *mut wavefront_plot_t,
    ) -> *mut wavefront_bialigner_t;
}
extern "C" {
    pub fn wavefront_bialigner_reap(wf_bialigner: *mut wavefront_bialigner_t);
}
extern "C" {
    pub fn wavefront_bialigner_delete(wf_bialigner: *mut wavefront_bialigner_t);
}
extern "C" {
    pub fn wavefront_bialigner_set_sequences_ascii(
        wf_bialigner: *mut wavefront_bialigner_t,
        pattern: *const ::std::os::raw::c_char,
        pattern_length: ::std::os::raw::c_int,
        text: *const ::std::os::raw::c_char,
        text_length: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_bialigner_set_sequences_lambda(
        wf_bialigner: *mut wavefront_bialigner_t,
        match_funct: alignment_match_funct_t,
        match_funct_arguments: *mut ::std::os::raw::c_void,
        pattern_length: ::std::os::raw::c_int,
        text_length: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_bialigner_set_sequences_packed2bits(
        wf_bialigner: *mut wavefront_bialigner_t,
        pattern: *const u8,
        pattern_length: ::std::os::raw::c_int,
        text: *const u8,
        text_length: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_bialigner_set_sequences_bounds(
        wf_bialigner: *mut wavefront_bialigner_t,
        pattern_begin: ::std::os::raw::c_int,
        pattern_end: ::std::os::raw::c_int,
        text_begin: ::std::os::raw::c_int,
        text_end: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_bialigner_get_size(wf_bialigner: *mut wavefront_bialigner_t) -> u64;
}
extern "C" {
    pub fn wavefront_bialigner_set_heuristic(
        wf_bialigner: *mut wavefront_bialigner_t,
        heuristic: *mut wavefront_heuristic_t,
    );
}
extern "C" {
    pub fn wavefront_bialigner_set_max_alignment_steps(
        wf_bialigner: *mut wavefront_bialigner_t,
        max_alignment_steps: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_bialigner_set_max_memory(
        wf_bialigner: *mut wavefront_bialigner_t,
        max_memory_resident: u64,
        max_memory_abort: u64,
    );
}
extern "C" {
    pub fn wavefront_bialigner_set_max_num_threads(
        wf_bialigner: *mut wavefront_bialigner_t,
        max_num_threads: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_bialigner_set_min_offsets_per_thread(
        wf_bialigner: *mut wavefront_bialigner_t,
        min_offsets_per_thread: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_align_strerror(
        error_code: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn wavefront_align_strerror_short(
        error_code: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct wavefront_align_status_t {
    pub status: ::std::os::raw::c_int,
    pub score: ::std::os::raw::c_int,
    pub dropped: bool,
    pub num_null_steps: ::std::os::raw::c_int,
    pub memory_used: u64,
    pub wf_align_compute: ::std::option::Option<
        unsafe extern "C" fn(arg1: *mut wavefront_aligner_t, arg2: ::std::os::raw::c_int),
    >,
    pub wf_align_extend: ::std::option::Option<
        unsafe extern "C" fn(
            arg1: *mut wavefront_aligner_t,
            arg2: ::std::os::raw::c_int,
        ) -> ::std::os::raw::c_int,
    >,
}
#[test]
fn bindgen_test_layout_wavefront_align_status_t() {
    const UNINIT: ::std::mem::MaybeUninit<wavefront_align_status_t> =
        ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<wavefront_align_status_t>(),
        40usize,
        concat!("Size of: ", stringify!(wavefront_align_status_t))
    );
    assert_eq!(
        ::std::mem::align_of::<wavefront_align_status_t>(),
        8usize,
        concat!("Alignment of ", stringify!(wavefront_align_status_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_align_status_t),
            "::",
            stringify!(status)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).score) as usize - ptr as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_align_status_t),
            "::",
            stringify!(score)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).dropped) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_align_status_t),
            "::",
            stringify!(dropped)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).num_null_steps) as usize - ptr as usize },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_align_status_t),
            "::",
            stringify!(num_null_steps)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).memory_used) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_align_status_t),
            "::",
            stringify!(memory_used)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wf_align_compute) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_align_status_t),
            "::",
            stringify!(wf_align_compute)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wf_align_extend) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(wavefront_align_status_t),
            "::",
            stringify!(wf_align_extend)
        )
    );
}
pub const wavefront_align_mode_t_wf_align_regular: wavefront_align_mode_t = 0;
pub const wavefront_align_mode_t_wf_align_biwfa: wavefront_align_mode_t = 1;
pub const wavefront_align_mode_t_wf_align_biwfa_breakpoint_forward: wavefront_align_mode_t = 2;
pub const wavefront_align_mode_t_wf_align_biwfa_breakpoint_reverse: wavefront_align_mode_t = 3;
pub const wavefront_align_mode_t_wf_align_biwfa_subsidiary: wavefront_align_mode_t = 4;
pub type wavefront_align_mode_t = ::std::os::raw::c_uint;
#[repr(C)]
pub struct _wavefront_aligner_t {
    pub align_mode: wavefront_align_mode_t,
    pub align_mode_tag: *mut ::std::os::raw::c_char,
    pub align_status: wavefront_align_status_t,
    pub sequences: wavefront_sequences_t,
    pub alignment_scope: alignment_scope_t,
    pub alignment_form: alignment_form_t,
    pub penalties: wavefront_penalties_t,
    pub heuristic: wavefront_heuristic_t,
    pub memory_mode: wavefront_memory_t,
    pub wf_components: wavefront_components_t,
    pub component_begin: affine2p_matrix_type,
    pub component_end: affine2p_matrix_type,
    pub alignment_end_pos: wavefront_pos_t,
    pub bialigner: *mut wavefront_bialigner_t,
    pub cigar: *mut cigar_t,
    pub mm_allocator_own: bool,
    pub mm_allocator: *mut mm_allocator_t,
    pub wavefront_slab: *mut wavefront_slab_t,
    pub plot: *mut wavefront_plot_t,
    pub system: alignment_system_t,
}
#[test]
fn bindgen_test_layout__wavefront_aligner_t() {
    const UNINIT: ::std::mem::MaybeUninit<_wavefront_aligner_t> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<_wavefront_aligner_t>(),
        648usize,
        concat!("Size of: ", stringify!(_wavefront_aligner_t))
    );
    assert_eq!(
        ::std::mem::align_of::<_wavefront_aligner_t>(),
        8usize,
        concat!("Alignment of ", stringify!(_wavefront_aligner_t))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).align_mode) as usize - ptr as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_wavefront_aligner_t),
            "::",
            stringify!(align_mode)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).align_mode_tag) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_wavefront_aligner_t),
            "::",
            stringify!(align_mode_tag)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).align_status) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_wavefront_aligner_t),
            "::",
            stringify!(align_status)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).sequences) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(_wavefront_aligner_t),
            "::",
            stringify!(sequences)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).alignment_scope) as usize - ptr as usize },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(_wavefront_aligner_t),
            "::",
            stringify!(alignment_scope)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).alignment_form) as usize - ptr as usize },
        164usize,
        concat!(
            "Offset of field: ",
            stringify!(_wavefront_aligner_t),
            "::",
            stringify!(alignment_form)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).penalties) as usize - ptr as usize },
        188usize,
        concat!(
            "Offset of field: ",
            stringify!(_wavefront_aligner_t),
            "::",
            stringify!(penalties)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).heuristic) as usize - ptr as usize },
        272usize,
        concat!(
            "Offset of field: ",
            stringify!(_wavefront_aligner_t),
            "::",
            stringify!(heuristic)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).memory_mode) as usize - ptr as usize },
        324usize,
        concat!(
            "Offset of field: ",
            stringify!(_wavefront_aligner_t),
            "::",
            stringify!(memory_mode)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wf_components) as usize - ptr as usize },
        328usize,
        concat!(
            "Offset of field: ",
            stringify!(_wavefront_aligner_t),
            "::",
            stringify!(wf_components)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).component_begin) as usize - ptr as usize },
        424usize,
        concat!(
            "Offset of field: ",
            stringify!(_wavefront_aligner_t),
            "::",
            stringify!(component_begin)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).component_end) as usize - ptr as usize },
        428usize,
        concat!(
            "Offset of field: ",
            stringify!(_wavefront_aligner_t),
            "::",
            stringify!(component_end)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).alignment_end_pos) as usize - ptr as usize },
        432usize,
        concat!(
            "Offset of field: ",
            stringify!(_wavefront_aligner_t),
            "::",
            stringify!(alignment_end_pos)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).bialigner) as usize - ptr as usize },
        448usize,
        concat!(
            "Offset of field: ",
            stringify!(_wavefront_aligner_t),
            "::",
            stringify!(bialigner)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).cigar) as usize - ptr as usize },
        456usize,
        concat!(
            "Offset of field: ",
            stringify!(_wavefront_aligner_t),
            "::",
            stringify!(cigar)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mm_allocator_own) as usize - ptr as usize },
        464usize,
        concat!(
            "Offset of field: ",
            stringify!(_wavefront_aligner_t),
            "::",
            stringify!(mm_allocator_own)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).mm_allocator) as usize - ptr as usize },
        472usize,
        concat!(
            "Offset of field: ",
            stringify!(_wavefront_aligner_t),
            "::",
            stringify!(mm_allocator)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).wavefront_slab) as usize - ptr as usize },
        480usize,
        concat!(
            "Offset of field: ",
            stringify!(_wavefront_aligner_t),
            "::",
            stringify!(wavefront_slab)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).plot) as usize - ptr as usize },
        488usize,
        concat!(
            "Offset of field: ",
            stringify!(_wavefront_aligner_t),
            "::",
            stringify!(plot)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).system) as usize - ptr as usize },
        496usize,
        concat!(
            "Offset of field: ",
            stringify!(_wavefront_aligner_t),
            "::",
            stringify!(system)
        )
    );
}
extern "C" {
    pub fn wavefront_aligner_new(
        attributes: *mut wavefront_aligner_attr_t,
    ) -> *mut wavefront_aligner_t;
}
extern "C" {
    pub fn wavefront_aligner_reap(wf_aligner: *mut wavefront_aligner_t);
}
extern "C" {
    pub fn wavefront_aligner_delete(wf_aligner: *mut wavefront_aligner_t);
}
extern "C" {
    pub fn wavefront_aligner_set_alignment_end_to_end(wf_aligner: *mut wavefront_aligner_t);
}
extern "C" {
    pub fn wavefront_aligner_set_alignment_free_ends(
        wf_aligner: *mut wavefront_aligner_t,
        pattern_begin_free: ::std::os::raw::c_int,
        pattern_end_free: ::std::os::raw::c_int,
        text_begin_free: ::std::os::raw::c_int,
        text_end_free: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_aligner_set_alignment_extension(wf_aligner: *mut wavefront_aligner_t);
}
extern "C" {
    pub fn wavefront_aligner_set_heuristic_none(wf_aligner: *mut wavefront_aligner_t);
}
extern "C" {
    pub fn wavefront_aligner_set_heuristic_wfadaptive(
        wf_aligner: *mut wavefront_aligner_t,
        min_wavefront_length: ::std::os::raw::c_int,
        max_distance_threshold: ::std::os::raw::c_int,
        score_steps: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_aligner_set_heuristic_wfmash(
        wf_aligner: *mut wavefront_aligner_t,
        min_wavefront_length: ::std::os::raw::c_int,
        max_distance_threshold: ::std::os::raw::c_int,
        score_steps: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_aligner_set_heuristic_xdrop(
        wf_aligner: *mut wavefront_aligner_t,
        xdrop: ::std::os::raw::c_int,
        score_steps: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_aligner_set_heuristic_zdrop(
        wf_aligner: *mut wavefront_aligner_t,
        ydrop: ::std::os::raw::c_int,
        score_steps: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_aligner_set_heuristic_banded_static(
        wf_aligner: *mut wavefront_aligner_t,
        band_min_k: ::std::os::raw::c_int,
        band_max_k: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_aligner_set_heuristic_banded_adaptive(
        wf_aligner: *mut wavefront_aligner_t,
        band_min_k: ::std::os::raw::c_int,
        band_max_k: ::std::os::raw::c_int,
        score_steps: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_aligner_set_max_alignment_steps(
        wf_aligner: *mut wavefront_aligner_t,
        max_alignment_steps: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_aligner_set_max_memory(
        wf_aligner: *mut wavefront_aligner_t,
        max_memory_resident: u64,
        max_memory_abort: u64,
    );
}
extern "C" {
    pub fn wavefront_aligner_set_max_num_threads(
        wf_aligner: *mut wavefront_aligner_t,
        max_num_threads: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_aligner_set_min_offsets_per_thread(
        wf_aligner: *mut wavefront_aligner_t,
        min_offsets_per_thread: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_align(
        wf_aligner: *mut wavefront_aligner_t,
        pattern: *const ::std::os::raw::c_char,
        pattern_length: ::std::os::raw::c_int,
        text: *const ::std::os::raw::c_char,
        text_length: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn wavefront_align_lambda(
        wf_aligner: *mut wavefront_aligner_t,
        match_funct: alignment_match_funct_t,
        match_funct_arguments: *mut ::std::os::raw::c_void,
        pattern_length: ::std::os::raw::c_int,
        text_length: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn wavefront_align_packed2bits(
        wf_aligner: *mut wavefront_aligner_t,
        pattern: *const u8,
        pattern_length: ::std::os::raw::c_int,
        text: *const u8,
        text_length: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn wavefront_aligner_init(
        wf_aligner: *mut wavefront_aligner_t,
        align_level: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn wavefront_aligner_get_size(wf_aligner: *mut wavefront_aligner_t) -> u64;
}
extern "C" {
    pub fn wavefront_aligner_maxtrim_cigar(wf_aligner: *mut wavefront_aligner_t) -> bool;
}
extern "C" {
    pub fn wavefront_aligner_print_mode(stream: *mut FILE, wf_aligner: *mut wavefront_aligner_t);
}
extern "C" {
    pub fn wavefront_aligner_print_scope(stream: *mut FILE, wf_aligner: *mut wavefront_aligner_t);
}
extern "C" {
    pub fn wavefront_aligner_print_conf(stream: *mut FILE, wf_aligner: *mut wavefront_aligner_t);
}