tree_sitter_c2rust/core_wrapper/core/

query.rs

use crate::core_transpiled::util::*;
use crate::core_transpiled::*;
use :: c2rust_bitfields;
use std::os;
pub type __uint8_t = libc::c_uchar;
pub type __int16_t = libc::c_short;
pub type __uint16_t = libc::c_ushort;
pub type __int32_t = libc::c_int;
pub type __uint32_t = libc::c_uint;
pub type __uint64_t = libc::c_ulong;
pub type __time_t = libc::c_long;
pub type __clockid_t = libc::c_int;
pub type __syscall_slong_t = libc::c_long;
pub type clockid_t = __clockid_t;
pub type int16_t = __int16_t;
pub type int32_t = __int32_t;
pub type uint8_t = __uint8_t;
pub type uint16_t = __uint16_t;
pub type uint32_t = __uint32_t;
pub type TSStateId = uint16_t;
pub type TSFieldId = uint16_t;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed {
    pub states: *const bool,
    pub symbol_map: *const TSSymbol,
    pub create: Option<unsafe extern "C" fn() -> *mut libc::c_void>,
    pub destroy: Option<unsafe extern "C" fn(*mut libc::c_void) -> ()>,
    pub scan: Option<unsafe extern "C" fn(*mut libc::c_void, *mut TSLexer, *const bool) -> bool>,
    pub serialize:
        Option<unsafe extern "C" fn(*mut libc::c_void, *mut libc::c_char) -> libc::c_uint>,
    pub deserialize:
        Option<unsafe extern "C" fn(*mut libc::c_void, *const libc::c_char, libc::c_uint) -> ()>,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_0 {
    pub count: uint8_t,
    pub reusable: bool,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_1 {
    pub type_: uint8_t,
    pub child_count: uint8_t,
    pub symbol: TSSymbol,
    pub dynamic_precedence: int16_t,
    pub production_id: uint16_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_2 {
    pub type_: uint8_t,
    pub state: TSStateId,
    pub extra: bool,
    pub repetition: bool,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct TSQuery {
    pub captures: SymbolTable,
    pub predicate_values: SymbolTable,
    pub capture_quantifiers: C2RustUnnamed_11,
    pub steps: C2RustUnnamed_10,
    pub pattern_map: C2RustUnnamed_9,
    pub predicate_steps: C2RustUnnamed_8,
    pub patterns: C2RustUnnamed_7,
    pub step_offsets: C2RustUnnamed_6,
    pub negated_fields: C2RustUnnamed_5,
    pub string_buffer: C2RustUnnamed_4,
    pub repeat_symbols_with_rootless_patterns: C2RustUnnamed_3,
    pub language: *const TSLanguage,
    pub wildcard_root_pattern_count: uint16_t,
}
type C2RustUnnamed_3 = crate::core_transpiled::util::StackElement<*mut TSSymbol>;
type C2RustUnnamed_4 = crate::core_transpiled::util::StackElement<*mut libc::c_char>;
type C2RustUnnamed_5 = crate::core_transpiled::util::StackElement<*mut TSFieldId>;
type C2RustUnnamed_6 = crate::core_transpiled::util::StackElement<*mut StepOffset>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct StepOffset {
    pub byte_offset: uint32_t,
    pub step_index: uint16_t,
}
type C2RustUnnamed_7 = crate::core_transpiled::util::StackElement<*mut QueryPattern>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct QueryPattern {
    pub steps: Slice,
    pub predicate_steps: Slice,
    pub start_byte: uint32_t,
    pub end_byte: uint32_t,
    pub is_non_local: bool,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct Slice {
    pub offset: uint32_t,
    pub length: uint32_t,
}
type C2RustUnnamed_8 = crate::core_transpiled::util::StackElement<*mut TSQueryPredicateStep>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct TSQueryPredicateStep {
    pub type_: TSQueryPredicateStepType,
    pub value_id: uint32_t,
}
type C2RustUnnamed_9 = crate::core_transpiled::util::StackElement<*mut PatternEntry>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct PatternEntry {
    pub step_index: uint16_t,
    pub pattern_index: uint16_t,
    pub is_rooted: bool,
}
type C2RustUnnamed_10 = crate::core_transpiled::util::StackElement<*mut QueryStep>;
#[derive(Copy, Clone, BitfieldStruct)]
#[repr(C)]
pub struct QueryStep {
    pub symbol: TSSymbol,
    pub supertype_symbol: TSSymbol,
    pub field: TSFieldId,
    pub capture_ids: [uint16_t; 3],
    pub depth: uint16_t,
    pub alternative_index: uint16_t,
    pub negated_field_list_id: uint16_t,
    #[bitfield(name = "is_named", ty = "bool", bits = "0..=0")]
    #[bitfield(name = "is_immediate", ty = "bool", bits = "1..=1")]
    #[bitfield(name = "is_last_child", ty = "bool", bits = "2..=2")]
    #[bitfield(name = "is_pass_through", ty = "bool", bits = "3..=3")]
    #[bitfield(name = "is_dead_end", ty = "bool", bits = "4..=4")]
    #[bitfield(name = "alternative_is_immediate", ty = "bool", bits = "5..=5")]
    #[bitfield(name = "contains_captures", ty = "bool", bits = "6..=6")]
    #[bitfield(name = "root_pattern_guaranteed", ty = "bool", bits = "7..=7")]
    #[bitfield(name = "parent_pattern_guaranteed", ty = "bool", bits = "8..=8")]
    pub is_named_is_immediate_is_last_child_is_pass_through_is_dead_end_alternative_is_immediate_contains_captures_root_pattern_guaranteed_parent_pattern_guaranteed:
        [u8; 2],
}
type C2RustUnnamed_11 = crate::core_transpiled::util::StackElement<*mut CaptureQuantifiers>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct CaptureQuantifiers {
    pub contents: *mut uint8_t,
    pub size: uint32_t,
    pub capacity: uint32_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct SymbolTable {
    pub characters: C2RustUnnamed_13,
    pub slices: C2RustUnnamed_12,
}
type C2RustUnnamed_12 = crate::core_transpiled::util::StackElement<*mut Slice>;
type C2RustUnnamed_13 = crate::core_transpiled::util::StackElement<*mut libc::c_char>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct TSQueryCursor {
    pub query: *const TSQuery,
    pub cursor: TSTreeCursor,
    pub states: C2RustUnnamed_16,
    pub finished_states: C2RustUnnamed_15,
    pub capture_list_pool: CaptureListPool,
    pub depth: uint32_t,
    pub max_start_depth: uint32_t,
    pub start_byte: uint32_t,
    pub end_byte: uint32_t,
    pub start_point: TSPoint,
    pub end_point: TSPoint,
    pub next_state_id: uint32_t,
    pub end_clock: TSClock,
    pub timeout_duration: TSDuration,
    pub operation_count: libc::c_uint,
    pub on_visible_node: bool,
    pub ascending: bool,
    pub halted: bool,
    pub did_exceed_match_limit: bool,
}
pub type TSDuration = uint64_t;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct CaptureListPool {
    pub list: C2RustUnnamed_14,
    pub empty_list: CaptureList,
    pub max_capture_list_count: uint32_t,
    pub free_capture_list_count: uint32_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct CaptureList {
    pub contents: *mut TSQueryCapture,
    pub size: uint32_t,
    pub capacity: uint32_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct TSQueryCapture {
    pub node: TSNode,
    pub index: uint32_t,
}
type C2RustUnnamed_14 = crate::core_transpiled::util::StackElement<*mut CaptureList>;
type C2RustUnnamed_15 = crate::core_transpiled::util::StackElement<*mut QueryState>;
#[derive(Copy, Clone, BitfieldStruct)]
#[repr(C)]
pub struct QueryState {
    pub id: uint32_t,
    pub capture_list_id: uint32_t,
    pub start_depth: uint16_t,
    pub step_index: uint16_t,
    pub pattern_index: uint16_t,
    #[bitfield(name = "consumed_capture_count", ty = "uint16_t", bits = "0..=11")]
    #[bitfield(name = "seeking_immediate_match", ty = "bool", bits = "12..=12")]
    #[bitfield(name = "has_in_progress_alternatives", ty = "bool", bits = "13..=13")]
    #[bitfield(name = "dead", ty = "bool", bits = "14..=14")]
    #[bitfield(name = "needs_parent", ty = "bool", bits = "15..=15")]
    pub consumed_capture_count_seeking_immediate_match_has_in_progress_alternatives_dead_needs_parent:
        [u8; 2],
}
type C2RustUnnamed_16 = crate::core_transpiled::util::StackElement<*mut QueryState>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct TSQueryMatch {
    pub id: uint32_t,
    pub pattern_index: uint16_t,
    pub capture_count: uint16_t,
    pub captures: *const TSQueryCapture,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct Array {
    pub contents: *mut libc::c_void,
    pub size: uint32_t,
    pub capacity: uint32_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct StatePredecessorMap {
    pub contents: *mut TSStateId,
}
type C2RustUnnamed_17 = crate::core_transpiled::util::StackElement<*mut uint16_t>;
type C2RustUnnamed_18 = crate::core_transpiled::util::StackElement<*mut uint32_t>;
type C2RustUnnamed_19 = crate::core_transpiled::util::StackElement<*mut uint16_t>;
type C2RustUnnamed_20 = crate::core_transpiled::util::StackElement<*mut AnalysisSubgraphNode>;
#[derive(Copy, Clone, BitfieldStruct)]
#[repr(C)]
pub struct AnalysisSubgraphNode {
    pub state: TSStateId,
    pub production_id: uint16_t,
    #[bitfield(name = "child_index", ty = "uint8_t", bits = "0..=6")]
    #[bitfield(name = "done", ty = "bool", bits = "7..=7")]
    pub child_index_done: [u8; 1],
    #[bitfield(padding)]
    pub c2rust_padding: [u8; 1],
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct QueryAnalysis {
    pub states: AnalysisStateSet,
    pub next_states: AnalysisStateSet,
    pub deeper_states: AnalysisStateSet,
    pub state_pool: AnalysisStateSet,
    pub final_step_indices: C2RustUnnamed_22,
    pub finished_parent_symbols: C2RustUnnamed_21,
    pub did_abort: bool,
}
type C2RustUnnamed_21 = crate::core_transpiled::util::StackElement<*mut TSSymbol>;
type C2RustUnnamed_22 = crate::core_transpiled::util::StackElement<*mut uint16_t>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AnalysisStateSet {
    pub contents: *mut *mut AnalysisState,
    pub size: uint32_t,
    pub capacity: uint32_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AnalysisState {
    pub stack: [AnalysisStateEntry; 8],
    pub depth: uint16_t,
    pub step_index: uint16_t,
    pub root_symbol: TSSymbol,
}
#[derive(Copy, Clone, BitfieldStruct)]
#[repr(C)]
pub struct AnalysisStateEntry {
    pub parse_state: TSStateId,
    pub parent_symbol: TSSymbol,
    pub child_index: uint16_t,
    #[bitfield(name = "field_id", ty = "TSFieldId", bits = "0..=14")]
    #[bitfield(name = "done", ty = "bool", bits = "15..=15")]
    pub field_id_done: [u8; 2],
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AnalysisSubgraphArray {
    pub contents: *mut AnalysisSubgraph,
    pub size: uint32_t,
    pub capacity: uint32_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct AnalysisSubgraph {
    pub symbol: TSSymbol,
    pub start_states: C2RustUnnamed_24,
    pub nodes: C2RustUnnamed_23,
}
type C2RustUnnamed_23 = crate::core_transpiled::util::StackElement<*mut AnalysisSubgraphNode>;
type C2RustUnnamed_24 = crate::core_transpiled::util::StackElement<*mut TSStateId>;
pub const TSParseActionTypeShift: C2RustUnnamed_31 = 0;
pub const TSParseActionTypeReduce: C2RustUnnamed_31 = 1;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct Stream {
    pub input: *const libc::c_char,
    pub start: *const libc::c_char,
    pub end: *const libc::c_char,
    pub next: int32_t,
    pub next_size: uint8_t,
}
pub type wint_t = libc::c_uint;
type C2RustUnnamed_25 = crate::core_transpiled::util::StackElement<*mut uint32_t>;
pub const TreeCursorStepHidden: TreeCursorStep = 1;
pub const TreeCursorStepVisible: TreeCursorStep = 2;
pub type TreeCursorStep = libc::c_uint;
pub const TreeCursorStepNone: TreeCursorStep = 0;
type C2RustUnnamed_26 = crate::core_transpiled::util::ScannerStateWithLookahead;
type C2RustUnnamed_27 = crate::core_transpiled::util::LongShortData;
type C2RustUnnamed_28 = crate::core_transpiled::util::ScannerStateLookaheadMeta;
type C2RustUnnamed_29 = crate::core_transpiled::util::ScannerStateLookaheadFirstLeaf;
type C2RustUnnamed_30 = crate::core_transpiled::util::StackElement<*mut TreeCursorEntry>;
pub type C2RustUnnamed_31 = libc::c_uint;
pub const TSParseActionTypeRecover: C2RustUnnamed_31 = 3;
pub const TSParseActionTypeAccept: C2RustUnnamed_31 = 2;
#[inline]
unsafe extern "C" fn _array__delete(mut self_0: *mut Array) {
    if !((*self_0).contents).is_null() {
        crate::core_transpiled::alloc::ts_free((*self_0).contents);
        (*self_0).contents = 0 as *mut libc::c_void;
        (*self_0).size = 0 as libc::c_int as uint32_t;
        (*self_0).capacity = 0 as libc::c_int as uint32_t;
    }
}
#[inline]
unsafe extern "C" fn _array__splice(
    mut self_0: *mut Array,
    mut element_size: size_t,
    mut index: uint32_t,
    mut old_count: uint32_t,
    mut new_count: uint32_t,
    mut elements: *const libc::c_void,
) {
    let mut new_size: uint32_t = ((*self_0).size)
        .wrapping_add(new_count)
        .wrapping_sub(old_count);
    let mut old_end: uint32_t = index.wrapping_add(old_count);
    let mut new_end: uint32_t = index.wrapping_add(new_count);
    if old_end <= (*self_0).size {
    } else {
        panic!();
    }
    _array__reserve(self_0, element_size, new_size);
    let mut contents: *mut libc::c_char = (*self_0).contents as *mut libc::c_char;
    if (*self_0).size > old_end {
        std::ptr::copy(
            contents.offset((old_end as libc::c_ulong).wrapping_mul(element_size) as isize)
                as *const libc::c_void,
            contents.offset((new_end as libc::c_ulong).wrapping_mul(element_size) as isize)
                as *mut libc::c_void,
            ((((*self_0).size).wrapping_sub(old_end) as libc::c_ulong).wrapping_mul(element_size))
                as usize,
        );
    }
    if new_count > 0 as libc::c_int as libc::c_uint {
        if !elements.is_null() {
            std::ptr::copy_nonoverlapping(
                elements,
                contents.offset((index as libc::c_ulong).wrapping_mul(element_size) as isize)
                    as *mut libc::c_void,
                (new_count as libc::c_ulong).wrapping_mul(element_size),
            );
        } else {
            std::ptr::write_bytes(
                contents.offset((index as libc::c_ulong).wrapping_mul(element_size) as isize)
                    as *mut libc::c_void,
                (0 as libc::c_int) as u8,
                ((new_count as libc::c_ulong).wrapping_mul(element_size)) as usize,
            );
        }
    }
    (*self_0).size = ((*self_0).size as libc::c_uint)
        .wrapping_add(new_count.wrapping_sub(old_count)) as uint32_t
        as uint32_t;
}
#[inline]
unsafe extern "C" fn _array__reserve(
    mut self_0: *mut Array,
    mut element_size: size_t,
    mut new_capacity: uint32_t,
) {
    if new_capacity > (*self_0).capacity {
        if !((*self_0).contents).is_null() {
            (*self_0).contents = crate::core_transpiled::alloc::ts_realloc(
                (*self_0).contents,
                (new_capacity as libc::c_ulong).wrapping_mul(element_size),
            );
        } else {
            (*self_0).contents = crate::core_transpiled::alloc::ts_malloc(
                (new_capacity as libc::c_ulong).wrapping_mul(element_size),
            );
        }
        (*self_0).capacity = new_capacity;
    }
}
#[inline]
unsafe extern "C" fn _array__grow(
    mut self_0: *mut Array,
    mut count: uint32_t,
    mut element_size: size_t,
) {
    let mut new_size: uint32_t = ((*self_0).size).wrapping_add(count);
    if new_size > (*self_0).capacity {
        let mut new_capacity: uint32_t =
            ((*self_0).capacity).wrapping_mul(2 as libc::c_int as libc::c_uint);
        if new_capacity < 8 as libc::c_int as libc::c_uint {
            new_capacity = 8 as libc::c_int as uint32_t;
        }
        if new_capacity < new_size {
            new_capacity = new_size;
        }
        _array__reserve(self_0, element_size, new_capacity);
    }
}
#[inline]
unsafe extern "C" fn _array__assign(
    mut self_0: *mut Array,
    mut other: *const Array,
    mut element_size: size_t,
) {
    _array__reserve(self_0, element_size, (*other).size);
    (*self_0).size = (*other).size;
    std::ptr::copy_nonoverlapping(
        (*other).contents,
        (*self_0).contents,
        ((*self_0).size as libc::c_ulong).wrapping_mul(element_size),
    );
}
#[inline]
unsafe extern "C" fn _array__erase(
    mut self_0: *mut Array,
    mut element_size: size_t,
    mut index: uint32_t,
) {
    if index < (*self_0).size {
    } else {
        panic!();
    }
    let mut contents: *mut libc::c_char = (*self_0).contents as *mut libc::c_char;
    std::ptr::copy(
        contents.offset(
            (index.wrapping_add(1 as libc::c_int as libc::c_uint) as libc::c_ulong)
                .wrapping_mul(element_size) as isize,
        ) as *const libc::c_void,
        contents.offset((index as libc::c_ulong).wrapping_mul(element_size) as isize)
            as *mut libc::c_void,
        ((((*self_0).size)
            .wrapping_sub(index)
            .wrapping_sub(1 as libc::c_int as libc::c_uint) as libc::c_ulong)
            .wrapping_mul(element_size)) as usize,
    );
    (*self_0).size = ((*self_0).size).wrapping_sub(1);
}
#[inline]
unsafe extern "C" fn duration_from_micros(mut micros: uint64_t) -> TSDuration {
    return micros;
}
#[inline]
unsafe extern "C" fn duration_to_micros(mut self_0: TSDuration) -> uint64_t {
    return self_0;
}
#[inline]
unsafe extern "C" fn clock_null() -> TSClock {
    return {
        let mut init = timespec {
            tv_sec: 0 as libc::c_int as __time_t,
            tv_nsec: 0 as libc::c_int as __syscall_slong_t,
        };
        init
    };
}
#[inline]
unsafe extern "C" fn clock_after(mut base: TSClock, mut duration: TSDuration) -> TSClock {
    let mut result: TSClock = base;
    result.tv_sec = (result.tv_sec as libc::c_ulong)
        .wrapping_add((duration as usize).wrapping_div(1000000 as libc::c_int as libc::c_ulong))
        as __time_t as __time_t;
    result.tv_nsec = (result.tv_nsec as libc::c_ulong).wrapping_add(
        (duration as usize)
            .wrapping_rem(1000000 as libc::c_int as libc::c_ulong)
            .wrapping_mul(1000 as libc::c_int as libc::c_ulong),
    ) as __syscall_slong_t as __syscall_slong_t;
    if result.tv_nsec >= 1000000000 as libc::c_int as libc::c_long {
        result.tv_nsec -= 1000000000 as libc::c_int as libc::c_long;
        result.tv_sec += 1;
    }
    return result;
}
#[inline]
unsafe extern "C" fn clock_is_null(mut self_0: TSClock) -> bool {
    return self_0.tv_sec == 0 && self_0.tv_nsec == 0;
}
#[inline]
unsafe extern "C" fn clock_is_gt(mut self_0: TSClock, mut other: TSClock) -> bool {
    if self_0.tv_sec > other.tv_sec {
        return 1 as libc::c_int != 0;
    }
    if self_0.tv_sec < other.tv_sec {
        return 0 as libc::c_int != 0;
    }
    return self_0.tv_nsec > other.tv_nsec;
}
#[inline]
unsafe extern "C" fn ts_subtree_symbol(mut self_0: Subtree) -> TSSymbol {
    return (if (self_0.data).is_inline() as libc::c_int != 0 {
        self_0.data.symbol as libc::c_int
    } else {
        (*self_0.ptr).symbol as libc::c_int
    }) as TSSymbol;
}
#[inline]
unsafe extern "C" fn ts_language_aliases_for_symbol(
    mut self_0: *const TSLanguage,
    mut original_symbol: TSSymbol,
    mut start: *mut *const TSSymbol,
    mut end: *mut *const TSSymbol,
) {
    *start = &*((*self_0).public_symbol_map).offset(original_symbol as isize) as *const TSSymbol;
    *end = (*start).offset(1 as libc::c_int as isize);
    let mut idx: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    loop {
        let fresh0 = idx;
        idx = idx.wrapping_add(1);
        let mut symbol: TSSymbol = *((*self_0).alias_map).offset(fresh0 as isize);
        if symbol as libc::c_int == 0 as libc::c_int
            || symbol as libc::c_int > original_symbol as libc::c_int
        {
            break;
        }
        let fresh1 = idx;
        idx = idx.wrapping_add(1);
        let mut count: uint16_t = *((*self_0).alias_map).offset(fresh1 as isize);
        if symbol as libc::c_int == original_symbol as libc::c_int {
            *start = &*((*self_0).alias_map).offset(idx as isize) as *const uint16_t;
            *end = &*((*self_0).alias_map).offset(idx.wrapping_add(count as libc::c_uint) as isize)
                as *const uint16_t;
            break;
        } else {
            idx = idx.wrapping_add(count as libc::c_uint);
        }
    }
}
#[inline]
unsafe extern "C" fn ts_language_state_is_primary(
    mut self_0: *const TSLanguage,
    mut state: TSStateId,
) -> bool {
    if (*self_0).version >= 14 as libc::c_int as libc::c_uint {
        return state as libc::c_int
            == *((*self_0).primary_state_ids).offset(state as isize) as libc::c_int;
    } else {
        return 1 as libc::c_int != 0;
    };
}
#[inline]
unsafe extern "C" fn ts_lookahead_iterator__next(mut self_0: *mut LookaheadIterator) -> bool {
    if (*self_0).is_small_state {
        (*self_0).data = ((*self_0).data).offset(1);
        if (*self_0).data == (*self_0).group_end {
            if (*self_0).group_count as libc::c_int == 0 as libc::c_int {
                return 0 as libc::c_int != 0;
            }
            (*self_0).group_count = ((*self_0).group_count).wrapping_sub(1);
            let fresh2 = (*self_0).data;
            (*self_0).data = ((*self_0).data).offset(1);
            (*self_0).table_value = *fresh2;
            let fresh3 = (*self_0).data;
            (*self_0).data = ((*self_0).data).offset(1);
            let mut symbol_count: libc::c_uint = *fresh3 as libc::c_uint;
            (*self_0).group_end = ((*self_0).data).offset(symbol_count as isize);
            (*self_0).symbol = *(*self_0).data;
        } else {
            (*self_0).symbol = *(*self_0).data;
            return 1 as libc::c_int != 0;
        }
    } else {
        loop {
            (*self_0).data = ((*self_0).data).offset(1);
            (*self_0).symbol = ((*self_0).symbol).wrapping_add(1);
            if (*self_0).symbol as libc::c_uint >= (*(*self_0).language).symbol_count {
                return 0 as libc::c_int != 0;
            }
            (*self_0).table_value = *(*self_0).data;
            if !((*self_0).table_value == 0) {
                break;
            }
        }
    }
    if ((*self_0).symbol as libc::c_uint) < (*(*self_0).language).token_count {
        let mut entry: *const TSParseActionEntry = &*((*(*self_0).language).parse_actions)
            .offset((*self_0).table_value as isize)
            as *const TSParseActionEntry;
        (*self_0).action_count = (*entry).entry.count as uint16_t;
        (*self_0).actions = entry.offset(1 as libc::c_int as isize) as *const TSParseAction;
        (*self_0).next_state = 0 as libc::c_int as TSStateId;
    } else {
        (*self_0).action_count = 0 as libc::c_int as uint16_t;
        (*self_0).next_state = (*self_0).table_value;
    }
    return 1 as libc::c_int != 0;
}
#[inline]
unsafe extern "C" fn ts_language_field_map(
    mut self_0: *const TSLanguage,
    mut production_id: uint32_t,
    mut start: *mut *const TSFieldMapEntry,
    mut end: *mut *const TSFieldMapEntry,
) {
    if (*self_0).field_count == 0 as libc::c_int as libc::c_uint {
        *start = 0 as *const TSFieldMapEntry;
        *end = 0 as *const TSFieldMapEntry;
        return;
    }
    let mut slice: TSFieldMapSlice = *((*self_0).field_map_slices).offset(production_id as isize);
    *start = &*((*self_0).field_map_entries).offset(slice.index as isize) as *const TSFieldMapEntry;
    *end = (&*((*self_0).field_map_entries).offset(slice.index as isize) as *const TSFieldMapEntry)
        .offset(slice.length as libc::c_int as isize);
}
#[inline]
unsafe extern "C" fn ts_language_alias_at(
    mut self_0: *const TSLanguage,
    mut production_id: uint32_t,
    mut child_index: uint32_t,
) -> TSSymbol {
    return (if production_id != 0 {
        *((*self_0).alias_sequences).offset(
            production_id
                .wrapping_mul((*self_0).max_alias_sequence_length as libc::c_uint)
                .wrapping_add(child_index) as isize,
        ) as libc::c_int
    } else {
        0 as libc::c_int
    }) as TSSymbol;
}
#[inline]
unsafe extern "C" fn ts_language_lookaheads(
    mut self_0: *const TSLanguage,
    mut state: TSStateId,
) -> LookaheadIterator {
    let mut is_small_state: bool = state as libc::c_uint >= (*self_0).large_state_count;
    let mut data: *const uint16_t = 0 as *const uint16_t;
    let mut group_end: *const uint16_t = 0 as *const uint16_t;
    let mut group_count: uint16_t = 0 as libc::c_int as uint16_t;
    if is_small_state {
        let mut index: uint32_t = *((*self_0).small_parse_table_map)
            .offset((state as libc::c_uint).wrapping_sub((*self_0).large_state_count) as isize);
        data = &*((*self_0).small_parse_table).offset(index as isize) as *const uint16_t;
        group_end = data.offset(1 as libc::c_int as isize);
        group_count = *data;
    } else {
        data = (&*((*self_0).parse_table)
            .offset((state as libc::c_uint).wrapping_mul((*self_0).symbol_count) as isize)
            as *const uint16_t)
            .offset(-(1 as libc::c_int as isize));
    }
    return {
        let mut init = LookaheadIterator {
            language: self_0,
            data: data,
            group_end: group_end,
            state: 0,
            table_value: 0,
            section_index: 0,
            group_count: group_count,
            is_small_state: is_small_state,
            actions: 0 as *const TSParseAction,
            symbol: 65535 as libc::c_int as TSSymbol,
            next_state: 0 as libc::c_int as TSStateId,
            action_count: 0,
        };
        init
    };
}
#[inline]
unsafe extern "C" fn ts_subtree_is_repetition(mut self_0: Subtree) -> uint32_t {
    return (if (self_0.data).is_inline() as libc::c_int != 0 {
        0 as libc::c_int
    } else {
        (!(*self_0.ptr).named()
            && !(*self_0.ptr).visible()
            && (*self_0.ptr).child_count != 0 as libc::c_int as libc::c_uint) as libc::c_int
    }) as uint32_t;
}
#[inline]
unsafe extern "C" fn point_lte(mut a: TSPoint, mut b: TSPoint) -> bool {
    return a.row < b.row || a.row == b.row && a.column <= b.column;
}
#[inline]
unsafe extern "C" fn point_lt(mut a: TSPoint, mut b: TSPoint) -> bool {
    return a.row < b.row || a.row == b.row && a.column < b.column;
}
#[inline]
unsafe extern "C" fn point_eq(mut a: TSPoint, mut b: TSPoint) -> bool {
    return a.row == b.row && a.column == b.column;
}
#[inline]
unsafe extern "C" fn point_gte(mut a: TSPoint, mut b: TSPoint) -> bool {
    return a.row > b.row || a.row == b.row && a.column >= b.column;
}
#[inline]
unsafe extern "C" fn ts_tree_cursor_current_subtree(mut _self: *const TSTreeCursor) -> Subtree {
    let mut self_0: *const TreeCursor = _self as *const TreeCursor;
    if ((*self_0).stack.size).wrapping_sub(1 as libc::c_int as libc::c_uint) < (*self_0).stack.size
    {
    } else {
        panic!();
    }
    let mut last_entry: *mut TreeCursorEntry = &mut *((*self_0).stack.contents)
        .offset(((*self_0).stack.size).wrapping_sub(1 as libc::c_int as libc::c_uint) as isize)
        as *mut TreeCursorEntry;
    return *(*last_entry).subtree;
}
#[inline]
unsafe extern "C" fn ts_decode_utf8(
    mut string: *const uint8_t,
    mut length: uint32_t,
    mut code_point: *mut int32_t,
) -> uint32_t {
    let mut i: uint32_t = 0 as libc::c_int as uint32_t;
    let fresh4 = i;
    i = i.wrapping_add(1);
    *code_point = *string.offset(fresh4 as isize) as int32_t;
    if !(*code_point & 0x80 as libc::c_int == 0 as libc::c_int) {
        let mut __t: uint8_t = 0 as libc::c_int as uint8_t;
        if !(i != length
            && (if *code_point >= 0xe0 as libc::c_int {
                ((if *code_point < 0xf0 as libc::c_int {
                    *code_point &= 0xf as libc::c_int;
                    __t = *string.offset(i as isize);
                    ((*::core::mem::transmute::<&[u8; 17], &[libc::c_char; 17]>(
                        b" 000000000000\x1000\0",
                    ))[*code_point as usize] as libc::c_int
                        & (1 as libc::c_int) << (__t as libc::c_int >> 5 as libc::c_int)
                        != 0
                        && {
                            __t = (__t as libc::c_int & 0x3f as libc::c_int) as uint8_t;
                            1 as libc::c_int != 0
                        }) as libc::c_int
                } else {
                    *code_point -= 0xf0 as libc::c_int;
                    (*code_point <= 4 as libc::c_int
                        && {
                            __t = *string.offset(i as isize);
                            (*::core::mem::transmute::<&[u8; 17], &[libc::c_char; 17]>(
                                b"\0\0\0\0\0\0\0\0\x1E\x0F\x0F\x0F\0\0\0\0\0",
                            ))[(__t as libc::c_int >> 4 as libc::c_int) as usize]
                                as libc::c_int
                                & (1 as libc::c_int) << *code_point
                                != 0
                        }
                        && {
                            *code_point = *code_point << 6 as libc::c_int
                                | __t as libc::c_int & 0x3f as libc::c_int;
                            i = i.wrapping_add(1);
                            i != length
                        }
                        && {
                            __t = (*string.offset(i as isize) as libc::c_int - 0x80 as libc::c_int)
                                as uint8_t;
                            __t as libc::c_int <= 0x3f as libc::c_int
                        }) as libc::c_int
                }) != 0
                    && {
                        *code_point = *code_point << 6 as libc::c_int | __t as libc::c_int;
                        i = i.wrapping_add(1);
                        i != length
                    }) as libc::c_int
            } else {
                (*code_point >= 0xc2 as libc::c_int && {
                    *code_point &= 0x1f as libc::c_int;
                    1 as libc::c_int != 0
                }) as libc::c_int
            }) != 0
            && {
                __t = (*string.offset(i as isize) as libc::c_int - 0x80 as libc::c_int) as uint8_t;
                __t as libc::c_int <= 0x3f as libc::c_int
            }
            && {
                *code_point = *code_point << 6 as libc::c_int | __t as libc::c_int;
                i = i.wrapping_add(1);
                1 as libc::c_int != 0
            })
        {
            *code_point = -(1 as libc::c_int);
        }
    }
    return i;
}
static mut PARENT_DONE: TSQueryError = 4294967295 as TSQueryError;
static mut PATTERN_DONE_MARKER: uint16_t = 65535 as libc::c_int as uint16_t;
static mut NONE: uint16_t = 65535 as libc::c_int as uint16_t;
static mut WILDCARD_SYMBOL: TSSymbol = 0 as libc::c_int as TSSymbol;
static mut OP_COUNT_PER_QUERY_TIMEOUT_CHECK: libc::c_uint = 100 as libc::c_int as libc::c_uint;
unsafe extern "C" fn stream_advance(mut self_0: *mut Stream) -> bool {
    (*self_0).input = ((*self_0).input).offset((*self_0).next_size as libc::c_int as isize);
    if (*self_0).input < (*self_0).end {
        let mut size: uint32_t = ts_decode_utf8(
            (*self_0).input as *const uint8_t,
            ((*self_0).end).offset_from((*self_0).input) as libc::c_long as uint32_t,
            &mut (*self_0).next,
        );
        if size > 0 as libc::c_int as libc::c_uint {
            (*self_0).next_size = size as uint8_t;
            return 1 as libc::c_int != 0;
        }
    } else {
        (*self_0).next_size = 0 as libc::c_int as uint8_t;
        (*self_0).next = '\0' as i32;
    }
    return 0 as libc::c_int != 0;
}
unsafe extern "C" fn stream_reset(mut self_0: *mut Stream, mut input: *const libc::c_char) {
    (*self_0).input = input;
    (*self_0).next_size = 0 as libc::c_int as uint8_t;
    stream_advance(self_0);
}
unsafe extern "C" fn stream_new(mut string: *const libc::c_char, mut length: uint32_t) -> Stream {
    let mut self_0: Stream = {
        let mut init = Stream {
            input: string,
            start: string,
            end: string.offset(length as isize),
            next: 0 as libc::c_int,
            next_size: 0,
        };
        init
    };
    stream_advance(&mut self_0);
    return self_0;
}
unsafe extern "C" fn stream_skip_whitespace(mut self_0: *mut Stream) {
    loop {
        if iswspace((*self_0).next as wint_t) != 0 {
            stream_advance(self_0);
        } else {
            if !((*self_0).next == ';' as i32) {
                break;
            }
            stream_advance(self_0);
            while (*self_0).next != 0 && (*self_0).next != '\n' as i32 {
                if !stream_advance(self_0) {
                    break;
                }
            }
        }
    }
}
unsafe extern "C" fn stream_is_ident_start(mut self_0: *mut Stream) -> bool {
    return iswalnum((*self_0).next as wint_t) != 0
        || (*self_0).next == '_' as i32
        || (*self_0).next == '-' as i32;
}
unsafe extern "C" fn stream_scan_identifier(mut stream: *mut Stream) {
    loop {
        stream_advance(stream);
        if !(iswalnum((*stream).next as wint_t) != 0
            || (*stream).next == '_' as i32
            || (*stream).next == '-' as i32
            || (*stream).next == '.' as i32
            || (*stream).next == '?' as i32
            || (*stream).next == '!' as i32)
        {
            break;
        }
    }
}
unsafe extern "C" fn stream_offset(mut self_0: *mut Stream) -> uint32_t {
    return ((*self_0).input).offset_from((*self_0).start) as libc::c_long as uint32_t;
}
unsafe extern "C" fn capture_list_pool_new() -> CaptureListPool {
    return {
        let mut init = CaptureListPool {
            list: {
                let mut init = C2RustUnnamed_14 {
                    contents: 0 as *mut CaptureList,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
            empty_list: {
                let mut init = CaptureList {
                    contents: 0 as *mut TSQueryCapture,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
            max_capture_list_count: 4294967295 as libc::c_uint,
            free_capture_list_count: 0 as libc::c_int as uint32_t,
        };
        init
    };
}
unsafe extern "C" fn capture_list_pool_reset(mut self_0: *mut CaptureListPool) {
    let mut i: uint16_t = 0 as libc::c_int as uint16_t;
    while (i as libc::c_int) < (*self_0).list.size as uint16_t as libc::c_int {
        (*((*self_0).list.contents).offset(i as isize)).size = 4294967295 as libc::c_uint;
        i = i.wrapping_add(1);
    }
    (*self_0).free_capture_list_count = (*self_0).list.size;
}
unsafe extern "C" fn capture_list_pool_delete(mut self_0: *mut CaptureListPool) {
    let mut i: uint16_t = 0 as libc::c_int as uint16_t;
    while (i as libc::c_int) < (*self_0).list.size as uint16_t as libc::c_int {
        _array__delete(
            &mut *((*self_0).list.contents).offset(i as isize) as *mut CaptureList as *mut Array,
        );
        i = i.wrapping_add(1);
    }
    _array__delete(&mut (*self_0).list as *mut C2RustUnnamed_14 as *mut Array);
}
unsafe extern "C" fn capture_list_pool_get(
    mut self_0: *const CaptureListPool,
    mut id: uint16_t,
) -> *const CaptureList {
    if id as libc::c_uint >= (*self_0).list.size {
        return &(*self_0).empty_list;
    }
    return &mut *((*self_0).list.contents).offset(id as isize) as *mut CaptureList;
}
unsafe extern "C" fn capture_list_pool_get_mut(
    mut self_0: *mut CaptureListPool,
    mut id: uint16_t,
) -> *mut CaptureList {
    if (id as libc::c_uint) < (*self_0).list.size {
    } else {
        panic!();
    }
    return &mut *((*self_0).list.contents).offset(id as isize) as *mut CaptureList;
}
unsafe extern "C" fn capture_list_pool_is_empty(mut self_0: *const CaptureListPool) -> bool {
    return (*self_0).free_capture_list_count == 0 as libc::c_int as libc::c_uint
        && (*self_0).list.size >= (*self_0).max_capture_list_count;
}
unsafe extern "C" fn capture_list_pool_acquire(mut self_0: *mut CaptureListPool) -> uint16_t {
    if (*self_0).free_capture_list_count > 0 as libc::c_int as libc::c_uint {
        let mut i: uint16_t = 0 as libc::c_int as uint16_t;
        while (i as libc::c_int) < (*self_0).list.size as uint16_t as libc::c_int {
            if (*((*self_0).list.contents).offset(i as isize)).size == 4294967295 as libc::c_uint {
                (*((*self_0).list.contents).offset(i as isize)).size = 0 as libc::c_int as uint32_t;
                (*self_0).free_capture_list_count =
                    ((*self_0).free_capture_list_count).wrapping_sub(1);
                return i;
            }
            i = i.wrapping_add(1);
        }
    }
    let mut i_0: uint32_t = (*self_0).list.size;
    if i_0 >= (*self_0).max_capture_list_count {
        return NONE;
    }
    let mut list: CaptureList = CaptureList {
        contents: 0 as *mut TSQueryCapture,
        size: 0,
        capacity: 0,
    };
    list.size = 0 as libc::c_int as uint32_t;
    list.capacity = 0 as libc::c_int as uint32_t;
    list.contents = 0 as *mut TSQueryCapture;
    _array__grow(
        &mut (*self_0).list as *mut C2RustUnnamed_14 as *mut Array,
        1 as libc::c_int as uint32_t,
        ::core::mem::size_of::<CaptureList>() as libc::c_ulong,
    );
    let fresh5 = (*self_0).list.size;
    (*self_0).list.size = ((*self_0).list.size).wrapping_add(1);
    *((*self_0).list.contents).offset(fresh5 as isize) = list;
    return i_0 as uint16_t;
}
unsafe extern "C" fn capture_list_pool_release(mut self_0: *mut CaptureListPool, mut id: uint16_t) {
    if id as libc::c_uint >= (*self_0).list.size {
        return;
    }
    (*((*self_0).list.contents).offset(id as isize)).size = 4294967295 as libc::c_uint;
    (*self_0).free_capture_list_count = ((*self_0).free_capture_list_count).wrapping_add(1);
}
unsafe extern "C" fn quantifier_mul(
    mut left: TSQuantifier,
    mut right: TSQuantifier,
) -> TSQuantifier {
    match left as libc::c_uint {
        0 => return TSQuantifierZero,
        1 => match right as libc::c_uint {
            0 => return TSQuantifierZero,
            1 | 3 => return TSQuantifierZeroOrOne,
            2 | 4 => return TSQuantifierZeroOrMore,
            _ => {}
        },
        2 => match right as libc::c_uint {
            0 => return TSQuantifierZero,
            1 | 2 | 3 | 4 => return TSQuantifierZeroOrMore,
            _ => {}
        },
        3 => return right,
        4 => match right as libc::c_uint {
            0 => return TSQuantifierZero,
            1 | 2 => return TSQuantifierZeroOrMore,
            3 | 4 => return TSQuantifierOneOrMore,
            _ => {}
        },
        _ => {}
    }
    return TSQuantifierZero;
}
unsafe extern "C" fn quantifier_join(
    mut left: TSQuantifier,
    mut right: TSQuantifier,
) -> TSQuantifier {
    match left as libc::c_uint {
        0 => match right as libc::c_uint {
            0 => return TSQuantifierZero,
            1 | 3 => return TSQuantifierZeroOrOne,
            2 | 4 => return TSQuantifierZeroOrMore,
            _ => {}
        },
        1 => match right as libc::c_uint {
            0 | 1 | 3 => return TSQuantifierZeroOrOne,
            2 | 4 => return TSQuantifierZeroOrMore,
            _ => {}
        },
        2 => return TSQuantifierZeroOrMore,
        3 => match right as libc::c_uint {
            0 | 1 => return TSQuantifierZeroOrOne,
            2 => return TSQuantifierZeroOrMore,
            3 => return TSQuantifierOne,
            4 => return TSQuantifierOneOrMore,
            _ => {}
        },
        4 => match right as libc::c_uint {
            0 | 1 | 2 => return TSQuantifierZeroOrMore,
            3 | 4 => return TSQuantifierOneOrMore,
            _ => {}
        },
        _ => {}
    }
    return TSQuantifierZero;
}
unsafe extern "C" fn quantifier_add(
    mut left: TSQuantifier,
    mut right: TSQuantifier,
) -> TSQuantifier {
    match left as libc::c_uint {
        0 => return right,
        1 => match right as libc::c_uint {
            0 => return TSQuantifierZeroOrOne,
            1 | 2 => return TSQuantifierZeroOrMore,
            3 | 4 => return TSQuantifierOneOrMore,
            _ => {}
        },
        2 => match right as libc::c_uint {
            0 => return TSQuantifierZeroOrMore,
            1 | 2 => return TSQuantifierZeroOrMore,
            3 | 4 => return TSQuantifierOneOrMore,
            _ => {}
        },
        3 => match right as libc::c_uint {
            0 => return TSQuantifierOne,
            1 | 2 | 3 | 4 => return TSQuantifierOneOrMore,
            _ => {}
        },
        4 => return TSQuantifierOneOrMore,
        _ => {}
    }
    return TSQuantifierZero;
}
unsafe extern "C" fn capture_quantifiers_new() -> CaptureQuantifiers {
    return {
        let mut init = CaptureQuantifiers {
            contents: 0 as *mut uint8_t,
            size: 0 as libc::c_int as uint32_t,
            capacity: 0 as libc::c_int as uint32_t,
        };
        init
    };
}
unsafe extern "C" fn capture_quantifiers_delete(mut self_0: *mut CaptureQuantifiers) {
    _array__delete(self_0 as *mut Array);
}
unsafe extern "C" fn capture_quantifiers_clear(mut self_0: *mut CaptureQuantifiers) {
    (*self_0).size = 0 as libc::c_int as uint32_t;
}
unsafe extern "C" fn capture_quantifiers_replace(
    mut self_0: *mut CaptureQuantifiers,
    mut quantifiers: *mut CaptureQuantifiers,
) {
    (*self_0).size = 0 as libc::c_int as uint32_t;
    _array__splice(
        self_0 as *mut Array,
        ::core::mem::size_of::<uint8_t>() as libc::c_ulong,
        (*self_0).size,
        0 as libc::c_int as uint32_t,
        (*quantifiers).size,
        (*quantifiers).contents as *const libc::c_void,
    );
}
unsafe extern "C" fn capture_quantifier_for_id(
    mut self_0: *const CaptureQuantifiers,
    mut id: uint16_t,
) -> TSQuantifier {
    return (if (*self_0).size <= id as libc::c_uint {
        TSQuantifierZero as libc::c_int as libc::c_uint
    } else {
        if (id as uint32_t) < (*self_0).size {
        } else {
            panic!();
        }
        *(&mut *((*self_0).contents).offset(id as isize) as *mut uint8_t) as TSQuantifier
            as libc::c_uint
    }) as TSQuantifier;
}
unsafe extern "C" fn capture_quantifiers_add_for_id(
    mut self_0: *mut CaptureQuantifiers,
    mut id: uint16_t,
    mut quantifier: TSQuantifier,
) {
    if (*self_0).size <= id as libc::c_uint {
        if !(((id as libc::c_int + 1 as libc::c_int) as libc::c_uint).wrapping_sub((*self_0).size)
            == 0 as libc::c_int as libc::c_uint)
        {
            _array__grow(
                self_0 as *mut Array,
                ((id as libc::c_int + 1 as libc::c_int) as libc::c_uint)
                    .wrapping_sub((*self_0).size),
                ::core::mem::size_of::<uint8_t>() as libc::c_ulong,
            );
            std::ptr::write_bytes(
                ((*self_0).contents).offset((*self_0).size as isize) as *mut libc::c_void,
                (0 as libc::c_int) as u8,
                ((((id as libc::c_int + 1 as libc::c_int) as libc::c_uint)
                    .wrapping_sub((*self_0).size) as libc::c_ulong)
                    .wrapping_mul(::core::mem::size_of::<uint8_t>() as libc::c_ulong))
                    as usize,
            );
            (*self_0).size = ((*self_0).size as libc::c_uint).wrapping_add(
                ((id as libc::c_int + 1 as libc::c_int) as libc::c_uint)
                    .wrapping_sub((*self_0).size),
            ) as uint32_t as uint32_t;
        }
    }
    if (id as uint32_t) < (*self_0).size {
    } else {
        panic!();
    }
    let mut own_quantifier: *mut uint8_t =
        &mut *((*self_0).contents).offset(id as isize) as *mut uint8_t;
    *own_quantifier = quantifier_add(*own_quantifier as TSQuantifier, quantifier) as uint8_t;
}
unsafe extern "C" fn capture_quantifiers_add_all(
    mut self_0: *mut CaptureQuantifiers,
    mut quantifiers: *mut CaptureQuantifiers,
) {
    if (*self_0).size < (*quantifiers).size {
        if !(((*quantifiers).size).wrapping_sub((*self_0).size) == 0 as libc::c_int as libc::c_uint)
        {
            _array__grow(
                self_0 as *mut Array,
                ((*quantifiers).size).wrapping_sub((*self_0).size),
                ::core::mem::size_of::<uint8_t>() as libc::c_ulong,
            );
            std::ptr::write_bytes(
                ((*self_0).contents).offset((*self_0).size as isize) as *mut libc::c_void,
                (0 as libc::c_int) as u8,
                ((((*quantifiers).size).wrapping_sub((*self_0).size) as libc::c_ulong)
                    .wrapping_mul(::core::mem::size_of::<uint8_t>() as libc::c_ulong))
                    as usize,
            );
            (*self_0).size = ((*self_0).size as libc::c_uint)
                .wrapping_add(((*quantifiers).size).wrapping_sub((*self_0).size))
                as uint32_t as uint32_t;
        }
    }
    let mut id: uint16_t = 0 as libc::c_int as uint16_t;
    while (id as libc::c_int) < (*quantifiers).size as uint16_t as libc::c_int {
        if (id as uint32_t) < (*quantifiers).size {
        } else {
            panic!();
        }
        let mut quantifier: *mut uint8_t =
            &mut *((*quantifiers).contents).offset(id as isize) as *mut uint8_t;
        if (id as uint32_t) < (*self_0).size {
        } else {
            panic!();
        }
        let mut own_quantifier: *mut uint8_t =
            &mut *((*self_0).contents).offset(id as isize) as *mut uint8_t;
        *own_quantifier =
            quantifier_add(*own_quantifier as TSQuantifier, *quantifier as TSQuantifier) as uint8_t;
        id = id.wrapping_add(1);
    }
}
unsafe extern "C" fn capture_quantifiers_mul(
    mut self_0: *mut CaptureQuantifiers,
    mut quantifier: TSQuantifier,
) {
    let mut id: uint16_t = 0 as libc::c_int as uint16_t;
    while (id as libc::c_int) < (*self_0).size as uint16_t as libc::c_int {
        if (id as uint32_t) < (*self_0).size {
        } else {
            panic!();
        }
        let mut own_quantifier: *mut uint8_t =
            &mut *((*self_0).contents).offset(id as isize) as *mut uint8_t;
        *own_quantifier = quantifier_mul(*own_quantifier as TSQuantifier, quantifier) as uint8_t;
        id = id.wrapping_add(1);
    }
}
unsafe extern "C" fn capture_quantifiers_join_all(
    mut self_0: *mut CaptureQuantifiers,
    mut quantifiers: *mut CaptureQuantifiers,
) {
    if (*self_0).size < (*quantifiers).size {
        if !(((*quantifiers).size).wrapping_sub((*self_0).size) == 0 as libc::c_int as libc::c_uint)
        {
            _array__grow(
                self_0 as *mut Array,
                ((*quantifiers).size).wrapping_sub((*self_0).size),
                ::core::mem::size_of::<uint8_t>() as libc::c_ulong,
            );
            std::ptr::write_bytes(
                ((*self_0).contents).offset((*self_0).size as isize) as *mut libc::c_void,
                (0 as libc::c_int) as u8,
                ((((*quantifiers).size).wrapping_sub((*self_0).size) as libc::c_ulong)
                    .wrapping_mul(::core::mem::size_of::<uint8_t>() as libc::c_ulong))
                    as usize,
            );
            (*self_0).size = ((*self_0).size as libc::c_uint)
                .wrapping_add(((*quantifiers).size).wrapping_sub((*self_0).size))
                as uint32_t as uint32_t;
        }
    }
    let mut id: uint32_t = 0 as libc::c_int as uint32_t;
    while id < (*quantifiers).size {
        if id < (*quantifiers).size {
        } else {
            panic!();
        }
        let mut quantifier: *mut uint8_t =
            &mut *((*quantifiers).contents).offset(id as isize) as *mut uint8_t;
        if id < (*self_0).size {
        } else {
            panic!();
        }
        let mut own_quantifier: *mut uint8_t =
            &mut *((*self_0).contents).offset(id as isize) as *mut uint8_t;
        *own_quantifier =
            quantifier_join(*own_quantifier as TSQuantifier, *quantifier as TSQuantifier)
                as uint8_t;
        id = id.wrapping_add(1);
    }
    let mut id_0: uint32_t = (*quantifiers).size;
    while id_0 < (*self_0).size {
        if id_0 < (*self_0).size {
        } else {
            panic!();
        }
        let mut own_quantifier_0: *mut uint8_t =
            &mut *((*self_0).contents).offset(id_0 as isize) as *mut uint8_t;
        *own_quantifier_0 =
            quantifier_join(*own_quantifier_0 as TSQuantifier, TSQuantifierZero) as uint8_t;
        id_0 = id_0.wrapping_add(1);
    }
}
unsafe extern "C" fn symbol_table_new() -> SymbolTable {
    return {
        let mut init = SymbolTable {
            characters: {
                let mut init = C2RustUnnamed_13 {
                    contents: 0 as *mut libc::c_char,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
            slices: {
                let mut init = C2RustUnnamed_12 {
                    contents: 0 as *mut Slice,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
        };
        init
    };
}
unsafe extern "C" fn symbol_table_delete(mut self_0: *mut SymbolTable) {
    _array__delete(&mut (*self_0).characters as *mut C2RustUnnamed_13 as *mut Array);
    _array__delete(&mut (*self_0).slices as *mut C2RustUnnamed_12 as *mut Array);
}
unsafe extern "C" fn symbol_table_id_for_name(
    mut self_0: *const SymbolTable,
    mut name: *const libc::c_char,
    mut length: uint32_t,
) -> libc::c_int {
    let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i < (*self_0).slices.size {
        let mut slice: Slice = *((*self_0).slices.contents).offset(i as isize);
        if slice.length == length
            && strncmp(
                &mut *((*self_0).characters.contents).offset(slice.offset as isize),
                name,
                length as libc::c_ulong,
            ) == 0
        {
            return i as libc::c_int;
        }
        i = i.wrapping_add(1);
    }
    return -(1 as libc::c_int);
}
unsafe extern "C" fn symbol_table_name_for_id(
    mut self_0: *const SymbolTable,
    mut id: uint16_t,
    mut length: *mut uint32_t,
) -> *const libc::c_char {
    let mut slice: Slice = *((*self_0).slices.contents).offset(id as isize);
    *length = slice.length;
    return &mut *((*self_0).characters.contents).offset(slice.offset as isize)
        as *mut libc::c_char;
}
unsafe extern "C" fn symbol_table_insert_name(
    mut self_0: *mut SymbolTable,
    mut name: *const libc::c_char,
    mut length: uint32_t,
) -> uint16_t {
    let mut id: libc::c_int = symbol_table_id_for_name(self_0, name, length);
    if id >= 0 as libc::c_int {
        return id as uint16_t;
    }
    let mut slice: Slice = {
        let mut init = Slice {
            offset: (*self_0).characters.size,
            length: length,
        };
        init
    };
    if !(length.wrapping_add(1 as libc::c_int as libc::c_uint) == 0 as libc::c_int as libc::c_uint)
    {
        _array__grow(
            &mut (*self_0).characters as *mut C2RustUnnamed_13 as *mut Array,
            length.wrapping_add(1 as libc::c_int as libc::c_uint),
            ::core::mem::size_of::<libc::c_char>() as libc::c_ulong,
        );
        std::ptr::write_bytes(
            ((*self_0).characters.contents).offset((*self_0).characters.size as isize)
                as *mut libc::c_void,
            (0 as libc::c_int) as u8,
            ((length.wrapping_add(1 as libc::c_int as libc::c_uint) as libc::c_ulong)
                .wrapping_mul(::core::mem::size_of::<libc::c_char>() as libc::c_ulong))
                as usize,
        );
        (*self_0).characters.size = ((*self_0).characters.size as libc::c_uint)
            .wrapping_add(length.wrapping_add(1 as libc::c_int as libc::c_uint))
            as uint32_t as uint32_t;
    }
    std::ptr::copy_nonoverlapping(
        name as *const libc::c_void,
        &mut *((*self_0).characters.contents).offset(slice.offset as isize) as *mut libc::c_char
            as *mut libc::c_void,
        length as libc::c_ulong,
    );
    *((*self_0).characters.contents).offset(
        ((*self_0).characters.size).wrapping_sub(1 as libc::c_int as libc::c_uint) as isize,
    ) = 0 as libc::c_int as libc::c_char;
    _array__grow(
        &mut (*self_0).slices as *mut C2RustUnnamed_12 as *mut Array,
        1 as libc::c_int as uint32_t,
        ::core::mem::size_of::<Slice>() as libc::c_ulong,
    );
    let fresh6 = (*self_0).slices.size;
    (*self_0).slices.size = ((*self_0).slices.size).wrapping_add(1);
    *((*self_0).slices.contents).offset(fresh6 as isize) = slice;
    return ((*self_0).slices.size).wrapping_sub(1 as libc::c_int as libc::c_uint) as uint16_t;
}
unsafe extern "C" fn query_step__new(
    mut symbol: TSSymbol,
    mut depth: uint16_t,
    mut is_immediate: bool,
) -> QueryStep {
    let mut step: QueryStep = {
        let mut init = QueryStep { is_named_is_immediate_is_last_child_is_pass_through_is_dead_end_alternative_is_immediate_contains_captures_root_pattern_guaranteed_parent_pattern_guaranteed : [0 ; 2] , symbol : symbol , supertype_symbol : 0 , field : 0 as libc :: c_int as TSFieldId , capture_ids : [0 ; 3] , depth : depth , alternative_index : NONE , negated_field_list_id : 0 as libc :: c_int as uint16_t , } ;
        init.set_is_named(0 as libc::c_int != 0);
        init.set_is_immediate(is_immediate);
        init.set_is_last_child(0 as libc::c_int != 0);
        init.set_is_pass_through(0 as libc::c_int != 0);
        init.set_is_dead_end(0 as libc::c_int != 0);
        init.set_alternative_is_immediate(0 as libc::c_int != 0);
        init.set_contains_captures(0 as libc::c_int != 0);
        init.set_root_pattern_guaranteed(0 as libc::c_int != 0);
        init.set_parent_pattern_guaranteed(false);
        init
    };
    let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i < 3 as libc::c_int as libc::c_uint {
        step.capture_ids[i as usize] = NONE;
        i = i.wrapping_add(1);
    }
    return step;
}
unsafe extern "C" fn query_step__add_capture(mut self_0: *mut QueryStep, mut capture_id: uint16_t) {
    let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i < 3 as libc::c_int as libc::c_uint {
        if (*self_0).capture_ids[i as usize] as libc::c_int == NONE as libc::c_int {
            (*self_0).capture_ids[i as usize] = capture_id;
            break;
        } else {
            i = i.wrapping_add(1);
        }
    }
}
unsafe extern "C" fn query_step__remove_capture(
    mut self_0: *mut QueryStep,
    mut capture_id: uint16_t,
) {
    let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i < 3 as libc::c_int as libc::c_uint {
        if (*self_0).capture_ids[i as usize] as libc::c_int == capture_id as libc::c_int {
            (*self_0).capture_ids[i as usize] = NONE;
            while i.wrapping_add(1 as libc::c_int as libc::c_uint)
                < 3 as libc::c_int as libc::c_uint
            {
                if (*self_0).capture_ids[i.wrapping_add(1 as libc::c_int as libc::c_uint) as usize]
                    as libc::c_int
                    == NONE as libc::c_int
                {
                    break;
                }
                (*self_0).capture_ids[i as usize] = (*self_0).capture_ids
                    [i.wrapping_add(1 as libc::c_int as libc::c_uint) as usize];
                (*self_0).capture_ids[i.wrapping_add(1 as libc::c_int as libc::c_uint) as usize] =
                    NONE;
                i = i.wrapping_add(1);
            }
            break;
        } else {
            i = i.wrapping_add(1);
        }
    }
}
#[inline]
unsafe extern "C" fn state_predecessor_map_new(
    mut language: *const TSLanguage,
) -> StatePredecessorMap {
    return {
        let mut init = StatePredecessorMap {
            contents: crate::core_transpiled::alloc::ts_calloc(
                ((*language).state_count as size_t)
                    .wrapping_mul((256 as libc::c_int + 1 as libc::c_int) as libc::c_ulong),
                ::core::mem::size_of::<TSStateId>() as libc::c_ulong,
            ) as *mut TSStateId,
        };
        init
    };
}
#[inline]
unsafe extern "C" fn state_predecessor_map_delete(mut self_0: *mut StatePredecessorMap) {
    crate::core_transpiled::alloc::ts_free((*self_0).contents as *mut libc::c_void);
}
#[inline]
unsafe extern "C" fn state_predecessor_map_add(
    mut self_0: *mut StatePredecessorMap,
    mut state: TSStateId,
    mut predecessor: TSStateId,
) {
    let mut index: size_t =
        (state as size_t).wrapping_mul((256 as libc::c_int + 1 as libc::c_int) as libc::c_ulong);
    let mut count: *mut TSStateId =
        &mut *((*self_0).contents).offset(index as isize) as *mut TSStateId;
    if *count as libc::c_int == 0 as libc::c_int
        || (*count as libc::c_int) < 256 as libc::c_int
            && *((*self_0).contents).offset(index.wrapping_add(*count as libc::c_ulong) as isize)
                as libc::c_int
                != predecessor as libc::c_int
    {
        *count = (*count).wrapping_add(1);
        *((*self_0).contents).offset(index.wrapping_add(*count as libc::c_ulong) as isize) =
            predecessor;
    }
}
#[inline]
unsafe extern "C" fn state_predecessor_map_get(
    mut self_0: *const StatePredecessorMap,
    mut state: TSStateId,
    mut count: *mut libc::c_uint,
) -> *const TSStateId {
    let mut index: size_t =
        (state as size_t).wrapping_mul((256 as libc::c_int + 1 as libc::c_int) as libc::c_ulong);
    *count = *((*self_0).contents).offset(index as isize) as libc::c_uint;
    return &mut *((*self_0).contents)
        .offset(index.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize)
        as *mut TSStateId;
}
unsafe extern "C" fn analysis_state__recursion_depth(
    mut self_0: *const AnalysisState,
) -> libc::c_uint {
    let mut result: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i < (*self_0).depth as libc::c_uint {
        let mut symbol: TSSymbol = (*self_0).stack[i as usize].parent_symbol;
        let mut j: libc::c_uint = 0 as libc::c_int as libc::c_uint;
        while j < i {
            if (*self_0).stack[j as usize].parent_symbol as libc::c_int == symbol as libc::c_int {
                result = result.wrapping_add(1);
                break;
            } else {
                j = j.wrapping_add(1);
            }
        }
        i = i.wrapping_add(1);
    }
    return result;
}
#[inline]
unsafe extern "C" fn analysis_state__compare_position(
    mut self_0: *const *mut AnalysisState,
    mut other: *const *mut AnalysisState,
) -> libc::c_int {
    let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i < (**self_0).depth as libc::c_uint {
        if i >= (**other).depth as libc::c_uint {
            return -(1 as libc::c_int);
        }
        if ((**self_0).stack[i as usize].child_index as libc::c_int)
            < (**other).stack[i as usize].child_index as libc::c_int
        {
            return -(1 as libc::c_int);
        }
        if (**self_0).stack[i as usize].child_index as libc::c_int
            > (**other).stack[i as usize].child_index as libc::c_int
        {
            return 1 as libc::c_int;
        }
        i = i.wrapping_add(1);
    }
    if ((**self_0).depth as libc::c_int) < (**other).depth as libc::c_int {
        return 1 as libc::c_int;
    }
    if ((**self_0).step_index as libc::c_int) < (**other).step_index as libc::c_int {
        return -(1 as libc::c_int);
    }
    if (**self_0).step_index as libc::c_int > (**other).step_index as libc::c_int {
        return 1 as libc::c_int;
    }
    return 0 as libc::c_int;
}
#[inline]
unsafe extern "C" fn analysis_state__compare(
    mut self_0: *const *mut AnalysisState,
    mut other: *const *mut AnalysisState,
) -> libc::c_int {
    let mut result: libc::c_int = analysis_state__compare_position(self_0, other);
    if result != 0 as libc::c_int {
        return result;
    }
    let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i < (**self_0).depth as libc::c_uint {
        if ((**self_0).stack[i as usize].parent_symbol as libc::c_int)
            < (**other).stack[i as usize].parent_symbol as libc::c_int
        {
            return -(1 as libc::c_int);
        }
        if (**self_0).stack[i as usize].parent_symbol as libc::c_int
            > (**other).stack[i as usize].parent_symbol as libc::c_int
        {
            return 1 as libc::c_int;
        }
        if ((**self_0).stack[i as usize].parse_state as libc::c_int)
            < (**other).stack[i as usize].parse_state as libc::c_int
        {
            return -(1 as libc::c_int);
        }
        if (**self_0).stack[i as usize].parse_state as libc::c_int
            > (**other).stack[i as usize].parse_state as libc::c_int
        {
            return 1 as libc::c_int;
        }
        if (((**self_0).stack[i as usize]).field_id() as libc::c_int)
            < ((**other).stack[i as usize]).field_id() as libc::c_int
        {
            return -(1 as libc::c_int);
        }
        if ((**self_0).stack[i as usize]).field_id() as libc::c_int
            > ((**other).stack[i as usize]).field_id() as libc::c_int
        {
            return 1 as libc::c_int;
        }
        i = i.wrapping_add(1);
    }
    return 0 as libc::c_int;
}
#[inline]
unsafe extern "C" fn analysis_state__top(
    mut self_0: *mut AnalysisState,
) -> *mut AnalysisStateEntry {
    if (*self_0).depth as libc::c_int == 0 as libc::c_int {
        return &mut *((*self_0).stack)
            .as_mut_ptr()
            .offset(0 as libc::c_int as isize) as *mut AnalysisStateEntry;
    }
    return &mut *((*self_0).stack)
        .as_mut_ptr()
        .offset(((*self_0).depth as libc::c_int - 1 as libc::c_int) as isize)
        as *mut AnalysisStateEntry;
}
#[inline]
unsafe extern "C" fn analysis_state__has_supertype(
    mut self_0: *mut AnalysisState,
    mut symbol: TSSymbol,
) -> bool {
    let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i < (*self_0).depth as libc::c_uint {
        if (*self_0).stack[i as usize].parent_symbol as libc::c_int == symbol as libc::c_int {
            return 1 as libc::c_int != 0;
        }
        i = i.wrapping_add(1);
    }
    return 0 as libc::c_int != 0;
}
#[inline]
unsafe extern "C" fn analysis_state_pool__clone_or_reuse(
    mut self_0: *mut AnalysisStateSet,
    mut borrowed_item: *mut AnalysisState,
) -> *mut AnalysisState {
    let mut new_item: *mut AnalysisState = 0 as *mut AnalysisState;
    if (*self_0).size != 0 {
        (*self_0).size = ((*self_0).size).wrapping_sub(1);
        new_item = *((*self_0).contents).offset((*self_0).size as isize);
    } else {
        new_item = crate::core_transpiled::alloc::ts_malloc(
            ::core::mem::size_of::<AnalysisState>() as libc::c_ulong
        ) as *mut AnalysisState;
    }
    *new_item = *borrowed_item;
    return new_item;
}
#[inline]
unsafe extern "C" fn analysis_state_set__insert_sorted(
    mut self_0: *mut AnalysisStateSet,
    mut pool: *mut AnalysisStateSet,
    mut borrowed_item: *mut AnalysisState,
) {
    let mut index: libc::c_uint = 0;
    let mut exists: libc::c_uint = 0;
    index = 0 as libc::c_int as libc::c_uint;
    exists = 0 as libc::c_int as libc::c_uint;
    let mut size: uint32_t = ((*self_0).size).wrapping_sub(index);
    if !(size == 0 as libc::c_int as libc::c_uint) {
        let mut comparison: libc::c_int = 0;
        while size > 1 as libc::c_int as libc::c_uint {
            let mut half_size: uint32_t = size.wrapping_div(2 as libc::c_int as libc::c_uint);
            let mut mid_index: uint32_t = index.wrapping_add(half_size);
            comparison = analysis_state__compare(
                &mut *((*self_0).contents).offset(mid_index as isize),
                &mut borrowed_item,
            );
            if comparison <= 0 as libc::c_int {
                index = mid_index;
            }
            size = (size as libc::c_uint).wrapping_sub(half_size) as uint32_t as uint32_t;
        }
        comparison = analysis_state__compare(
            &mut *((*self_0).contents).offset(index as isize),
            &mut borrowed_item,
        );
        if comparison == 0 as libc::c_int {
            exists = 1 as libc::c_int as libc::c_uint;
        } else if comparison < 0 as libc::c_int {
            index = index.wrapping_add(1 as libc::c_int as libc::c_uint);
        }
    }
    if exists == 0 {
        let mut new_item: *mut AnalysisState =
            analysis_state_pool__clone_or_reuse(pool, borrowed_item);
        _array__splice(
            self_0 as *mut Array,
            ::core::mem::size_of::<*mut AnalysisState>() as libc::c_ulong,
            index,
            0 as libc::c_int as uint32_t,
            1 as libc::c_int as uint32_t,
            &mut new_item as *mut *mut AnalysisState as *const libc::c_void,
        );
    }
}
#[inline]
unsafe extern "C" fn analysis_state_set__push(
    mut self_0: *mut AnalysisStateSet,
    mut pool: *mut AnalysisStateSet,
    mut borrowed_item: *mut AnalysisState,
) {
    let mut new_item: *mut AnalysisState = analysis_state_pool__clone_or_reuse(pool, borrowed_item);
    _array__grow(
        self_0 as *mut Array,
        1 as libc::c_int as uint32_t,
        ::core::mem::size_of::<*mut AnalysisState>() as libc::c_ulong,
    );
    let fresh7 = (*self_0).size;
    (*self_0).size = ((*self_0).size).wrapping_add(1);
    let ref mut fresh8 = *((*self_0).contents).offset(fresh7 as isize);
    *fresh8 = new_item;
}
#[inline]
unsafe extern "C" fn analysis_state_set__clear(
    mut self_0: *mut AnalysisStateSet,
    mut pool: *mut AnalysisStateSet,
) {
    _array__splice(
        pool as *mut Array,
        ::core::mem::size_of::<*mut AnalysisState>() as libc::c_ulong,
        (*pool).size,
        0 as libc::c_int as uint32_t,
        (*self_0).size,
        (*self_0).contents as *const libc::c_void,
    );
    (*self_0).size = 0 as libc::c_int as uint32_t;
}
#[inline]
unsafe extern "C" fn analysis_state_set__delete(mut self_0: *mut AnalysisStateSet) {
    let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i < (*self_0).size {
        crate::core_transpiled::alloc::ts_free(
            *((*self_0).contents).offset(i as isize) as *mut libc::c_void
        );
        i = i.wrapping_add(1);
    }
    _array__delete(self_0 as *mut Array);
}
#[inline]
unsafe extern "C" fn query_analysis__new() -> QueryAnalysis {
    return {
        let mut init = QueryAnalysis {
            states: {
                let mut init = AnalysisStateSet {
                    contents: 0 as *mut *mut AnalysisState,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
            next_states: {
                let mut init = AnalysisStateSet {
                    contents: 0 as *mut *mut AnalysisState,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
            deeper_states: {
                let mut init = AnalysisStateSet {
                    contents: 0 as *mut *mut AnalysisState,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
            state_pool: {
                let mut init = AnalysisStateSet {
                    contents: 0 as *mut *mut AnalysisState,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
            final_step_indices: {
                let mut init = C2RustUnnamed_22 {
                    contents: 0 as *mut uint16_t,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
            finished_parent_symbols: {
                let mut init = C2RustUnnamed_21 {
                    contents: 0 as *mut TSSymbol,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
            did_abort: 0 as libc::c_int != 0,
        };
        init
    };
}
#[inline]
unsafe extern "C" fn query_analysis__delete(mut self_0: *mut QueryAnalysis) {
    analysis_state_set__delete(&mut (*self_0).states);
    analysis_state_set__delete(&mut (*self_0).next_states);
    analysis_state_set__delete(&mut (*self_0).deeper_states);
    analysis_state_set__delete(&mut (*self_0).state_pool);
    _array__delete(&mut (*self_0).final_step_indices as *mut C2RustUnnamed_22 as *mut Array);
    _array__delete(&mut (*self_0).finished_parent_symbols as *mut C2RustUnnamed_21 as *mut Array);
}
#[inline]
unsafe extern "C" fn analysis_subgraph_node__compare(
    mut self_0: *const AnalysisSubgraphNode,
    mut other: *const AnalysisSubgraphNode,
) -> libc::c_int {
    if ((*self_0).state as libc::c_int) < (*other).state as libc::c_int {
        return -(1 as libc::c_int);
    }
    if (*self_0).state as libc::c_int > (*other).state as libc::c_int {
        return 1 as libc::c_int;
    }
    if ((*self_0).child_index() as libc::c_int) < (*other).child_index() as libc::c_int {
        return -(1 as libc::c_int);
    }
    if (*self_0).child_index() as libc::c_int > (*other).child_index() as libc::c_int {
        return 1 as libc::c_int;
    }
    if ((*self_0).done() as libc::c_int) < (*other).done() as libc::c_int {
        return -(1 as libc::c_int);
    }
    if (*self_0).done() as libc::c_int > (*other).done() as libc::c_int {
        return 1 as libc::c_int;
    }
    if ((*self_0).production_id as libc::c_int) < (*other).production_id as libc::c_int {
        return -(1 as libc::c_int);
    }
    if (*self_0).production_id as libc::c_int > (*other).production_id as libc::c_int {
        return 1 as libc::c_int;
    }
    return 0 as libc::c_int;
}
#[inline]
unsafe extern "C" fn ts_query__pattern_map_search(
    mut self_0: *const TSQuery,
    mut needle: TSSymbol,
    mut result: *mut uint32_t,
) -> bool {
    let mut base_index: uint32_t = (*self_0).wildcard_root_pattern_count as uint32_t;
    let mut size: uint32_t = ((*self_0).pattern_map.size).wrapping_sub(base_index);
    if size == 0 as libc::c_int as libc::c_uint {
        *result = base_index;
        return 0 as libc::c_int != 0;
    }
    while size > 1 as libc::c_int as libc::c_uint {
        let mut half_size: uint32_t = size.wrapping_div(2 as libc::c_int as libc::c_uint);
        let mut mid_index: uint32_t = base_index.wrapping_add(half_size);
        let mut mid_symbol: TSSymbol = (*((*self_0).steps.contents).offset(
            (*((*self_0).pattern_map.contents).offset(mid_index as isize)).step_index as isize,
        ))
        .symbol;
        if needle as libc::c_int > mid_symbol as libc::c_int {
            base_index = mid_index;
        }
        size = (size as libc::c_uint).wrapping_sub(half_size) as uint32_t as uint32_t;
    }
    let mut symbol: TSSymbol = (*((*self_0).steps.contents).offset(
        (*((*self_0).pattern_map.contents).offset(base_index as isize)).step_index as isize,
    ))
    .symbol;
    if needle as libc::c_int > symbol as libc::c_int {
        base_index = base_index.wrapping_add(1);
        if base_index < (*self_0).pattern_map.size {
            symbol = (*((*self_0).steps.contents).offset(
                (*((*self_0).pattern_map.contents).offset(base_index as isize)).step_index as isize,
            ))
            .symbol;
        }
    }
    *result = base_index;
    return needle as libc::c_int == symbol as libc::c_int;
}
#[inline]
unsafe extern "C" fn ts_query__pattern_map_insert(
    mut self_0: *mut TSQuery,
    mut symbol: TSSymbol,
    mut new_entry: PatternEntry,
) {
    let mut index: uint32_t = 0;
    ts_query__pattern_map_search(self_0, symbol, &mut index);
    while index < (*self_0).pattern_map.size {
        let mut entry: *mut PatternEntry =
            &mut *((*self_0).pattern_map.contents).offset(index as isize) as *mut PatternEntry;
        if !((*((*self_0).steps.contents).offset((*entry).step_index as isize)).symbol
            as libc::c_int
            == symbol as libc::c_int
            && ((*entry).pattern_index as libc::c_int) < new_entry.pattern_index as libc::c_int)
        {
            break;
        }
        index = index.wrapping_add(1);
    }
    _array__splice(
        &mut (*self_0).pattern_map as *mut C2RustUnnamed_9 as *mut Array,
        ::core::mem::size_of::<PatternEntry>() as libc::c_ulong,
        index,
        0 as libc::c_int as uint32_t,
        1 as libc::c_int as uint32_t,
        &mut new_entry as *mut PatternEntry as *const libc::c_void,
    );
}
unsafe extern "C" fn ts_query__perform_analysis(
    mut self_0: *mut TSQuery,
    mut subgraphs: *const AnalysisSubgraphArray,
    mut analysis: *mut QueryAnalysis,
) {
    let mut recursion_depth_limit: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    let mut prev_final_step_count: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    (*analysis).final_step_indices.size = 0 as libc::c_int as uint32_t;
    (*analysis).finished_parent_symbols.size = 0 as libc::c_int as uint32_t;
    let mut iteration: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    loop {
        if iteration == 256 as libc::c_int as libc::c_uint {
            (*analysis).did_abort = 1 as libc::c_int != 0;
            break;
        } else {
            if (*analysis).states.size == 0 as libc::c_int as libc::c_uint {
                if !((*analysis).deeper_states.size > 0 as libc::c_int as libc::c_uint
                    && (*analysis).final_step_indices.size > prev_final_step_count)
                {
                    break;
                }
                prev_final_step_count = (*analysis).final_step_indices.size;
                recursion_depth_limit = recursion_depth_limit.wrapping_add(1);
                let mut _states: AnalysisStateSet = (*analysis).states;
                (*analysis).states = (*analysis).deeper_states;
                (*analysis).deeper_states = _states;
            } else {
                analysis_state_set__clear(
                    &mut (*analysis).next_states,
                    &mut (*analysis).state_pool,
                );
                let mut current_block_136: u64;
                let mut j: libc::c_uint = 0 as libc::c_int as libc::c_uint;
                while j < (*analysis).states.size {
                    let state: *mut AnalysisState =
                        *((*analysis).states.contents).offset(j as isize);
                    if (*analysis).next_states.size > 0 as libc::c_int as libc::c_uint {
                        if ((*analysis).next_states.size)
                            .wrapping_sub(1 as libc::c_int as libc::c_uint)
                            < (*analysis).next_states.size
                        {
                        } else {
                            panic!();
                        }
                        let mut comparison: libc::c_int = analysis_state__compare_position(
                            &state,
                            &mut *((*analysis).next_states.contents).offset(
                                ((*analysis).next_states.size)
                                    .wrapping_sub(1 as libc::c_int as libc::c_uint)
                                    as isize,
                            ),
                        );
                        if comparison == 0 as libc::c_int {
                            analysis_state_set__insert_sorted(
                                &mut (*analysis).next_states,
                                &mut (*analysis).state_pool,
                                state,
                            );
                            current_block_136 = 1841672684692190573;
                        } else if comparison > 0 as libc::c_int {
                            while j < (*analysis).states.size {
                                analysis_state_set__push(
                                    &mut (*analysis).next_states,
                                    &mut (*analysis).state_pool,
                                    *((*analysis).states.contents).offset(j as isize),
                                );
                                j = j.wrapping_add(1);
                            }
                            break;
                        } else {
                            current_block_136 = 11042950489265723346;
                        }
                    } else {
                        current_block_136 = 11042950489265723346;
                    }
                    match current_block_136 {
                        11042950489265723346 => {
                            let parse_state: TSStateId = (*analysis_state__top(state)).parse_state;
                            let parent_symbol: TSSymbol =
                                (*analysis_state__top(state)).parent_symbol;
                            let parent_field_id: TSFieldId =
                                (*analysis_state__top(state)).field_id();
                            let child_index: libc::c_uint =
                                (*analysis_state__top(state)).child_index as libc::c_uint;
                            let step: *const QueryStep = &mut *((*self_0).steps.contents)
                                .offset((*state).step_index as isize)
                                as *mut QueryStep;
                            let mut subgraph_index: libc::c_uint = 0;
                            let mut exists: libc::c_uint = 0;
                            subgraph_index = 0 as libc::c_int as libc::c_uint;
                            exists = 0 as libc::c_int as libc::c_uint;
                            let mut size: uint32_t =
                                ((*subgraphs).size).wrapping_sub(subgraph_index);
                            if !(size == 0 as libc::c_int as libc::c_uint) {
                                let mut comparison_0: libc::c_int = 0;
                                while size > 1 as libc::c_int as libc::c_uint {
                                    let mut half_size: uint32_t =
                                        size.wrapping_div(2 as libc::c_int as libc::c_uint);
                                    let mut mid_index: uint32_t =
                                        subgraph_index.wrapping_add(half_size);
                                    comparison_0 = (*((*subgraphs).contents)
                                        .offset(mid_index as isize))
                                    .symbol
                                        as libc::c_int
                                        - parent_symbol as libc::c_int;
                                    if comparison_0 <= 0 as libc::c_int {
                                        subgraph_index = mid_index;
                                    }
                                    size = (size as libc::c_uint).wrapping_sub(half_size)
                                        as uint32_t
                                        as uint32_t;
                                }
                                comparison_0 =
                                    (*((*subgraphs).contents).offset(subgraph_index as isize))
                                        .symbol as libc::c_int
                                        - parent_symbol as libc::c_int;
                                if comparison_0 == 0 as libc::c_int {
                                    exists = 1 as libc::c_int as libc::c_uint;
                                } else if comparison_0 < 0 as libc::c_int {
                                    subgraph_index = subgraph_index
                                        .wrapping_add(1 as libc::c_int as libc::c_uint);
                                }
                            }
                            if !(exists == 0) {
                                let mut subgraph: *const AnalysisSubgraph =
                                    &mut *((*subgraphs).contents).offset(subgraph_index as isize)
                                        as *mut AnalysisSubgraph;
                                let mut lookahead_iterator: LookaheadIterator =
                                    ts_language_lookaheads((*self_0).language, parse_state);
                                while ts_lookahead_iterator__next(&mut lookahead_iterator) {
                                    let mut sym: TSSymbol = lookahead_iterator.symbol;
                                    let mut successor: AnalysisSubgraphNode = {
                                        let mut init = AnalysisSubgraphNode {
                                            child_index_done: [0; 1],
                                            c2rust_padding: [0; 1],
                                            state: parse_state,
                                            production_id: 0,
                                        };
                                        init.set_child_index(child_index as uint8_t);
                                        init.set_done(false);
                                        init
                                    };
                                    if lookahead_iterator.action_count != 0 {
                                        let mut action: *const TSParseAction =
                                            &*(lookahead_iterator.actions).offset(
                                                (lookahead_iterator.action_count as libc::c_int
                                                    - 1 as libc::c_int)
                                                    as isize,
                                            )
                                                as *const TSParseAction;
                                        if !((*action).type_ as libc::c_int
                                            == TSParseActionTypeShift as libc::c_int)
                                        {
                                            continue;
                                        }
                                        if !(*action).shift.extra {
                                            successor.state = (*action).shift.state;
                                            successor.set_child_index(successor.child_index() + 1);
                                        }
                                    } else {
                                        if !(lookahead_iterator.next_state as libc::c_int
                                            != 0 as libc::c_int)
                                        {
                                            continue;
                                        }
                                        successor.state = lookahead_iterator.next_state;
                                        successor.set_child_index(successor.child_index() + 1);
                                    }
                                    let mut node_index: libc::c_uint = 0;
                                    node_index = 0 as libc::c_int as libc::c_uint;
                                    exists = 0 as libc::c_int as libc::c_uint;
                                    let mut size_0: uint32_t =
                                        ((*subgraph).nodes.size).wrapping_sub(node_index);
                                    if !(size_0 == 0 as libc::c_int as libc::c_uint) {
                                        let mut comparison_1: libc::c_int = 0;
                                        while size_0 > 1 as libc::c_int as libc::c_uint {
                                            let mut half_size_0: uint32_t = size_0
                                                .wrapping_div(2 as libc::c_int as libc::c_uint);
                                            let mut mid_index_0: uint32_t =
                                                node_index.wrapping_add(half_size_0);
                                            comparison_1 = analysis_subgraph_node__compare(
                                                &mut *((*subgraph).nodes.contents)
                                                    .offset(mid_index_0 as isize),
                                                &mut successor,
                                            );
                                            if comparison_1 <= 0 as libc::c_int {
                                                node_index = mid_index_0;
                                            }
                                            size_0 = (size_0 as libc::c_uint)
                                                .wrapping_sub(half_size_0)
                                                as uint32_t
                                                as uint32_t;
                                        }
                                        comparison_1 = analysis_subgraph_node__compare(
                                            &mut *((*subgraph).nodes.contents)
                                                .offset(node_index as isize),
                                            &mut successor,
                                        );
                                        if comparison_1 == 0 as libc::c_int {
                                            exists = 1 as libc::c_int as libc::c_uint;
                                        } else if comparison_1 < 0 as libc::c_int {
                                            node_index = node_index
                                                .wrapping_add(1 as libc::c_int as libc::c_uint);
                                        }
                                    }
                                    while node_index < (*subgraph).nodes.size {
                                        let fresh9 = node_index;
                                        node_index = node_index.wrapping_add(1);
                                        let mut node: *mut AnalysisSubgraphNode =
                                            &mut *((*subgraph).nodes.contents)
                                                .offset(fresh9 as isize)
                                                as *mut AnalysisSubgraphNode;
                                        if (*node).state as libc::c_int
                                            != successor.state as libc::c_int
                                            || (*node).child_index() as libc::c_int
                                                != successor.child_index() as libc::c_int
                                        {
                                            break;
                                        }
                                        let mut alias: TSSymbol = ts_language_alias_at(
                                            (*self_0).language,
                                            (*node).production_id as uint32_t,
                                            child_index,
                                        );
                                        let mut visible_symbol: TSSymbol =
                                            (if alias as libc::c_int != 0 {
                                                alias as libc::c_int
                                            } else if (*((*(*self_0).language).symbol_metadata)
                                                .offset(sym as isize))
                                            .visible
                                                as libc::c_int
                                                != 0
                                            {
                                                *((*(*self_0).language).public_symbol_map)
                                                    .offset(sym as isize)
                                                    as libc::c_int
                                            } else {
                                                0 as libc::c_int
                                            })
                                                as TSSymbol;
                                        let mut field_id: TSFieldId = parent_field_id;
                                        if field_id == 0 {
                                            let mut field_map: *const TSFieldMapEntry =
                                                0 as *const TSFieldMapEntry;
                                            let mut field_map_end: *const TSFieldMapEntry =
                                                0 as *const TSFieldMapEntry;
                                            ts_language_field_map(
                                                (*self_0).language,
                                                (*node).production_id as uint32_t,
                                                &mut field_map,
                                                &mut field_map_end,
                                            );
                                            while field_map != field_map_end {
                                                if !(*field_map).inherited
                                                    && (*field_map).child_index as libc::c_uint
                                                        == child_index
                                                {
                                                    field_id = (*field_map).field_id;
                                                    break;
                                                } else {
                                                    field_map = field_map.offset(1);
                                                }
                                            }
                                        }
                                        let mut next_state: AnalysisState = *state;
                                        let mut next_state_top: *mut AnalysisStateEntry =
                                            analysis_state__top(&mut next_state);
                                        (*next_state_top).child_index =
                                            successor.child_index() as uint16_t;
                                        (*next_state_top).parse_state = successor.state;
                                        if (*node).done() {
                                            (*next_state_top).set_done(1 as libc::c_int != 0);
                                        }
                                        let mut does_match: bool = 0 as libc::c_int != 0;
                                        if visible_symbol != 0 {
                                            does_match = 1 as libc::c_int != 0;
                                            if (*step).symbol as libc::c_int
                                                == WILDCARD_SYMBOL as libc::c_int
                                            {
                                                if (*step).is_named() as libc::c_int != 0
                                                    && !(*((*(*self_0).language).symbol_metadata)
                                                        .offset(visible_symbol as isize))
                                                    .named
                                                {
                                                    does_match = 0 as libc::c_int != 0;
                                                }
                                            } else if (*step).symbol as libc::c_int
                                                != visible_symbol as libc::c_int
                                            {
                                                does_match = 0 as libc::c_int != 0;
                                            }
                                            if (*step).field as libc::c_int != 0
                                                && (*step).field as libc::c_int
                                                    != field_id as libc::c_int
                                            {
                                                does_match = 0 as libc::c_int != 0;
                                            }
                                            if (*step).supertype_symbol as libc::c_int != 0
                                                && !analysis_state__has_supertype(
                                                    state,
                                                    (*step).supertype_symbol,
                                                )
                                            {
                                                does_match = 0 as libc::c_int != 0;
                                            }
                                        } else if sym as libc::c_uint
                                            >= (*(*self_0).language).token_count
                                        {
                                            if !(*next_state_top).done() {
                                                if next_state.depth as libc::c_int
                                                    + 1 as libc::c_int
                                                    >= 8 as libc::c_int
                                                {
                                                    (*analysis).did_abort = 1 as libc::c_int != 0;
                                                    continue;
                                                } else {
                                                    next_state.depth =
                                                        (next_state.depth).wrapping_add(1);
                                                    next_state_top =
                                                        analysis_state__top(&mut next_state);
                                                }
                                            }
                                            *next_state_top = {
                                                let mut init = AnalysisStateEntry {
                                                    field_id_done: [0; 2],
                                                    parse_state: parse_state,
                                                    parent_symbol: sym,
                                                    child_index: 0 as libc::c_int as uint16_t,
                                                };
                                                init.set_field_id(field_id);
                                                init.set_done(0 as libc::c_int != 0);
                                                init
                                            };
                                            if analysis_state__recursion_depth(&mut next_state)
                                                > recursion_depth_limit
                                            {
                                                analysis_state_set__insert_sorted(
                                                    &mut (*analysis).deeper_states,
                                                    &mut (*analysis).state_pool,
                                                    &mut next_state,
                                                );
                                                continue;
                                            }
                                        }
                                        while next_state.depth as libc::c_int > 0 as libc::c_int
                                            && (*next_state_top).done() as libc::c_int != 0
                                        {
                                            next_state.depth = (next_state.depth).wrapping_sub(1);
                                            next_state_top = analysis_state__top(&mut next_state);
                                        }
                                        let mut next_step: *const QueryStep = step;
                                        if does_match {
                                            loop {
                                                next_state.step_index =
                                                    (next_state.step_index).wrapping_add(1);
                                                next_step = &mut *((*self_0).steps.contents)
                                                    .offset(next_state.step_index as isize)
                                                    as *mut QueryStep;
                                                if (*next_step).depth as libc::c_int
                                                    == PATTERN_DONE_MARKER as libc::c_int
                                                    || (*next_step).depth as libc::c_int
                                                        <= (*step).depth as libc::c_int
                                                {
                                                    break;
                                                }
                                            }
                                        } else if successor.state as libc::c_int
                                            == parse_state as libc::c_int
                                        {
                                            continue;
                                        }
                                        loop {
                                            if (*next_step).is_pass_through() {
                                                next_state.step_index =
                                                    (next_state.step_index).wrapping_add(1);
                                                next_step = next_step.offset(1);
                                            } else {
                                                if !(*next_step).is_dead_end() {
                                                    let mut did_finish_pattern: bool =
                                                        (*((*self_0).steps.contents)
                                                            .offset(next_state.step_index as isize))
                                                        .depth
                                                            as libc::c_int
                                                            != (*step).depth as libc::c_int;
                                                    if did_finish_pattern {
                                                        let mut _index: libc::c_uint = 0;
                                                        let mut _exists: libc::c_uint = 0;
                                                        _index = 0 as libc::c_int as libc::c_uint;
                                                        _exists = 0 as libc::c_int as libc::c_uint;
                                                        let mut size_1: uint32_t = ((*analysis)
                                                            .finished_parent_symbols
                                                            .size)
                                                            .wrapping_sub(_index);
                                                        if !(size_1
                                                            == 0 as libc::c_int as libc::c_uint)
                                                        {
                                                            let mut comparison_2: libc::c_int = 0;
                                                            while size_1
                                                                > 1 as libc::c_int as libc::c_uint
                                                            {
                                                                let mut half_size_1: uint32_t =
                                                                    size_1.wrapping_div(
                                                                        2 as libc::c_int
                                                                            as libc::c_uint,
                                                                    );
                                                                let mut mid_index_1: uint32_t =
                                                                    _index
                                                                        .wrapping_add(half_size_1);
                                                                comparison_2 = *((*analysis)
                                                                    .finished_parent_symbols
                                                                    .contents)
                                                                    .offset(mid_index_1 as isize)
                                                                    as libc::c_int
                                                                    - (*state).root_symbol
                                                                        as libc::c_int;
                                                                if comparison_2 <= 0 as libc::c_int
                                                                {
                                                                    _index = mid_index_1;
                                                                }
                                                                size_1 = (size_1 as libc::c_uint)
                                                                    .wrapping_sub(half_size_1)
                                                                    as uint32_t
                                                                    as uint32_t;
                                                            }
                                                            comparison_2 = *((*analysis)
                                                                .finished_parent_symbols
                                                                .contents)
                                                                .offset(_index as isize)
                                                                as libc::c_int
                                                                - (*state).root_symbol
                                                                    as libc::c_int;
                                                            if comparison_2 == 0 as libc::c_int {
                                                                _exists = 1 as libc::c_int
                                                                    as libc::c_uint;
                                                            } else if comparison_2
                                                                < 0 as libc::c_int
                                                            {
                                                                _index = _index.wrapping_add(
                                                                    1 as libc::c_int
                                                                        as libc::c_uint,
                                                                );
                                                            }
                                                        }
                                                        if _exists == 0 {
                                                            _array__splice(
                                                                &mut (*analysis)
                                                                    .finished_parent_symbols
                                                                    as *mut C2RustUnnamed_21
                                                                    as *mut Array,
                                                                ::core::mem::size_of::<TSSymbol>()
                                                                    as libc::c_ulong,
                                                                _index,
                                                                0 as libc::c_int as uint32_t,
                                                                1 as libc::c_int as uint32_t,
                                                                &mut (*state).root_symbol
                                                                    as *mut TSSymbol
                                                                    as *const libc::c_void,
                                                            );
                                                        }
                                                    } else if next_state.depth as libc::c_int
                                                        == 0 as libc::c_int
                                                    {
                                                        let mut _index_0: libc::c_uint = 0;
                                                        let mut _exists_0: libc::c_uint = 0;
                                                        _index_0 = 0 as libc::c_int as libc::c_uint;
                                                        _exists_0 =
                                                            0 as libc::c_int as libc::c_uint;
                                                        let mut size_2: uint32_t =
                                                            ((*analysis).final_step_indices.size)
                                                                .wrapping_sub(_index_0);
                                                        if !(size_2
                                                            == 0 as libc::c_int as libc::c_uint)
                                                        {
                                                            let mut comparison_3: libc::c_int = 0;
                                                            while size_2
                                                                > 1 as libc::c_int as libc::c_uint
                                                            {
                                                                let mut half_size_2: uint32_t =
                                                                    size_2.wrapping_div(
                                                                        2 as libc::c_int
                                                                            as libc::c_uint,
                                                                    );
                                                                let mut mid_index_2: uint32_t =
                                                                    _index_0
                                                                        .wrapping_add(half_size_2);
                                                                comparison_3 = *((*analysis)
                                                                    .final_step_indices
                                                                    .contents)
                                                                    .offset(mid_index_2 as isize)
                                                                    as libc::c_int
                                                                    - next_state.step_index
                                                                        as libc::c_int;
                                                                if comparison_3 <= 0 as libc::c_int
                                                                {
                                                                    _index_0 = mid_index_2;
                                                                }
                                                                size_2 = (size_2 as libc::c_uint)
                                                                    .wrapping_sub(half_size_2)
                                                                    as uint32_t
                                                                    as uint32_t;
                                                            }
                                                            comparison_3 = *((*analysis)
                                                                .final_step_indices
                                                                .contents)
                                                                .offset(_index_0 as isize)
                                                                as libc::c_int
                                                                - next_state.step_index
                                                                    as libc::c_int;
                                                            if comparison_3 == 0 as libc::c_int {
                                                                _exists_0 = 1 as libc::c_int
                                                                    as libc::c_uint;
                                                            } else if comparison_3
                                                                < 0 as libc::c_int
                                                            {
                                                                _index_0 = _index_0.wrapping_add(
                                                                    1 as libc::c_int
                                                                        as libc::c_uint,
                                                                );
                                                            }
                                                        }
                                                        if _exists_0 == 0 {
                                                            _array__splice(
                                                                &mut (*analysis).final_step_indices
                                                                    as *mut C2RustUnnamed_22
                                                                    as *mut Array,
                                                                ::core::mem::size_of::<uint16_t>()
                                                                    as libc::c_ulong,
                                                                _index_0,
                                                                0 as libc::c_int as uint32_t,
                                                                1 as libc::c_int as uint32_t,
                                                                &mut next_state.step_index
                                                                    as *mut uint16_t
                                                                    as *const libc::c_void,
                                                            );
                                                        }
                                                    } else {
                                                        analysis_state_set__insert_sorted(
                                                            &mut (*analysis).next_states,
                                                            &mut (*analysis).state_pool,
                                                            &mut next_state,
                                                        );
                                                    }
                                                }
                                                if !(does_match as libc::c_int != 0
                                                    && (*next_step).alternative_index
                                                        as libc::c_int
                                                        != NONE as libc::c_int
                                                    && (*next_step).alternative_index
                                                        as libc::c_int
                                                        > next_state.step_index as libc::c_int)
                                                {
                                                    break;
                                                }
                                                next_state.step_index =
                                                    (*next_step).alternative_index;
                                                next_step = &mut *((*self_0).steps.contents)
                                                    .offset(next_state.step_index as isize)
                                                    as *mut QueryStep;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        _ => {}
                    }
                    j = j.wrapping_add(1);
                }
                let mut _states_0: AnalysisStateSet = (*analysis).states;
                (*analysis).states = (*analysis).next_states;
                (*analysis).next_states = _states_0;
            }
            iteration = iteration.wrapping_add(1);
        }
    }
}
unsafe extern "C" fn ts_query__analyze_patterns(
    mut self_0: *mut TSQuery,
    mut error_offset: *mut libc::c_uint,
) -> bool {
    let mut non_rooted_pattern_start_steps: C2RustUnnamed_19 = {
        let mut init = C2RustUnnamed_19 {
            contents: 0 as *mut uint16_t,
            size: 0 as libc::c_int as uint32_t,
            capacity: 0 as libc::c_int as uint32_t,
        };
        init
    };
    let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i < (*self_0).pattern_map.size {
        let mut pattern: *mut PatternEntry =
            &mut *((*self_0).pattern_map.contents).offset(i as isize) as *mut PatternEntry;
        if !(*pattern).is_rooted {
            let mut step: *mut QueryStep = &mut *((*self_0).steps.contents)
                .offset((*pattern).step_index as isize)
                as *mut QueryStep;
            if (*step).symbol as libc::c_int != WILDCARD_SYMBOL as libc::c_int {
                _array__grow(
                    &mut non_rooted_pattern_start_steps as *mut C2RustUnnamed_19 as *mut Array,
                    1 as libc::c_int as uint32_t,
                    ::core::mem::size_of::<uint16_t>() as libc::c_ulong,
                );
                let fresh10 = non_rooted_pattern_start_steps.size;
                non_rooted_pattern_start_steps.size =
                    (non_rooted_pattern_start_steps.size).wrapping_add(1);
                *(non_rooted_pattern_start_steps.contents).offset(fresh10 as isize) = i as uint16_t;
            }
        }
        i = i.wrapping_add(1);
    }
    let mut parent_step_indices: C2RustUnnamed_18 = {
        let mut init = C2RustUnnamed_18 {
            contents: 0 as *mut uint32_t,
            size: 0 as libc::c_int as uint32_t,
            capacity: 0 as libc::c_int as uint32_t,
        };
        init
    };
    let mut i_0: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i_0 < (*self_0).steps.size {
        let mut step_0: *mut QueryStep =
            &mut *((*self_0).steps.contents).offset(i_0 as isize) as *mut QueryStep;
        if (*step_0).depth as libc::c_int == PATTERN_DONE_MARKER as libc::c_int {
            (*step_0).set_parent_pattern_guaranteed(1 as libc::c_int != 0);
            (*step_0).set_root_pattern_guaranteed(1 as libc::c_int != 0);
        } else {
            let mut has_children: bool = 0 as libc::c_int != 0;
            let mut is_wildcard: bool =
                (*step_0).symbol as libc::c_int == WILDCARD_SYMBOL as libc::c_int;
            (*step_0).set_contains_captures(
                (*step_0).capture_ids[0 as libc::c_int as usize] as libc::c_int
                    != NONE as libc::c_int,
            );
            let mut j: libc::c_uint = i_0.wrapping_add(1 as libc::c_int as libc::c_uint);
            while j < (*self_0).steps.size {
                let mut next_step: *mut QueryStep =
                    &mut *((*self_0).steps.contents).offset(j as isize) as *mut QueryStep;
                if (*next_step).depth as libc::c_int == PATTERN_DONE_MARKER as libc::c_int
                    || (*next_step).depth as libc::c_int <= (*step_0).depth as libc::c_int
                {
                    break;
                }
                if (*next_step).capture_ids[0 as libc::c_int as usize] as libc::c_int
                    != NONE as libc::c_int
                {
                    (*step_0).set_contains_captures(1 as libc::c_int != 0);
                }
                if !is_wildcard {
                    (*next_step).set_root_pattern_guaranteed(1 as libc::c_int != 0);
                    (*next_step).set_parent_pattern_guaranteed(1 as libc::c_int != 0);
                }
                has_children = 1 as libc::c_int != 0;
                j = j.wrapping_add(1);
            }
            if has_children as libc::c_int != 0 && !is_wildcard {
                _array__grow(
                    &mut parent_step_indices as *mut C2RustUnnamed_18 as *mut Array,
                    1 as libc::c_int as uint32_t,
                    ::core::mem::size_of::<uint32_t>() as libc::c_ulong,
                );
                let fresh11 = parent_step_indices.size;
                parent_step_indices.size = (parent_step_indices.size).wrapping_add(1);
                *(parent_step_indices.contents).offset(fresh11 as isize) = i_0;
            }
        }
        i_0 = i_0.wrapping_add(1);
    }
    let mut subgraphs: AnalysisSubgraphArray = {
        let mut init = AnalysisSubgraphArray {
            contents: 0 as *mut AnalysisSubgraph,
            size: 0 as libc::c_int as uint32_t,
            capacity: 0 as libc::c_int as uint32_t,
        };
        init
    };
    let mut i_1: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i_1 < parent_step_indices.size {
        let mut parent_step_index: uint32_t = *(parent_step_indices.contents).offset(i_1 as isize);
        let mut parent_symbol: TSSymbol =
            (*((*self_0).steps.contents).offset(parent_step_index as isize)).symbol;
        let mut subgraph: AnalysisSubgraph = {
            let mut init = AnalysisSubgraph {
                symbol: parent_symbol,
                start_states: C2RustUnnamed_24 {
                    contents: 0 as *mut TSStateId,
                    size: 0,
                    capacity: 0,
                },
                nodes: C2RustUnnamed_23 {
                    contents: 0 as *mut AnalysisSubgraphNode,
                    size: 0,
                    capacity: 0,
                },
            };
            init
        };
        let mut _index: libc::c_uint = 0;
        let mut _exists: libc::c_uint = 0;
        _index = 0 as libc::c_int as libc::c_uint;
        _exists = 0 as libc::c_int as libc::c_uint;
        let mut size: uint32_t = (subgraphs.size).wrapping_sub(_index);
        if !(size == 0 as libc::c_int as libc::c_uint) {
            let mut comparison: libc::c_int = 0;
            while size > 1 as libc::c_int as libc::c_uint {
                let mut half_size: uint32_t = size.wrapping_div(2 as libc::c_int as libc::c_uint);
                let mut mid_index: uint32_t = _index.wrapping_add(half_size);
                comparison = (*(subgraphs.contents).offset(mid_index as isize)).symbol
                    as libc::c_int
                    - subgraph.symbol as libc::c_int;
                if comparison <= 0 as libc::c_int {
                    _index = mid_index;
                }
                size = (size as libc::c_uint).wrapping_sub(half_size) as uint32_t as uint32_t;
            }
            comparison = (*(subgraphs.contents).offset(_index as isize)).symbol as libc::c_int
                - subgraph.symbol as libc::c_int;
            if comparison == 0 as libc::c_int {
                _exists = 1 as libc::c_int as libc::c_uint;
            } else if comparison < 0 as libc::c_int {
                _index = _index.wrapping_add(1 as libc::c_int as libc::c_uint);
            }
        }
        if _exists == 0 {
            _array__splice(
                &mut subgraphs as *mut AnalysisSubgraphArray as *mut Array,
                ::core::mem::size_of::<AnalysisSubgraph>() as libc::c_ulong,
                _index,
                0 as libc::c_int as uint32_t,
                1 as libc::c_int as uint32_t,
                &mut subgraph as *mut AnalysisSubgraph as *const libc::c_void,
            );
        }
        i_1 = i_1.wrapping_add(1);
    }
    let mut sym: TSSymbol = (*(*self_0).language).token_count as uint16_t;
    while (sym as libc::c_int) < (*(*self_0).language).symbol_count as uint16_t as libc::c_int {
        if !(ts_language_symbol_metadata((*self_0).language, sym)).visible {
            let mut subgraph_0: AnalysisSubgraph = {
                let mut init = AnalysisSubgraph {
                    symbol: sym,
                    start_states: C2RustUnnamed_24 {
                        contents: 0 as *mut TSStateId,
                        size: 0,
                        capacity: 0,
                    },
                    nodes: C2RustUnnamed_23 {
                        contents: 0 as *mut AnalysisSubgraphNode,
                        size: 0,
                        capacity: 0,
                    },
                };
                init
            };
            let mut _index_0: libc::c_uint = 0;
            let mut _exists_0: libc::c_uint = 0;
            _index_0 = 0 as libc::c_int as libc::c_uint;
            _exists_0 = 0 as libc::c_int as libc::c_uint;
            let mut size_0: uint32_t = (subgraphs.size).wrapping_sub(_index_0);
            if !(size_0 == 0 as libc::c_int as libc::c_uint) {
                let mut comparison_0: libc::c_int = 0;
                while size_0 > 1 as libc::c_int as libc::c_uint {
                    let mut half_size_0: uint32_t =
                        size_0.wrapping_div(2 as libc::c_int as libc::c_uint);
                    let mut mid_index_0: uint32_t = _index_0.wrapping_add(half_size_0);
                    comparison_0 = (*(subgraphs.contents).offset(mid_index_0 as isize)).symbol
                        as libc::c_int
                        - subgraph_0.symbol as libc::c_int;
                    if comparison_0 <= 0 as libc::c_int {
                        _index_0 = mid_index_0;
                    }
                    size_0 =
                        (size_0 as libc::c_uint).wrapping_sub(half_size_0) as uint32_t as uint32_t;
                }
                comparison_0 = (*(subgraphs.contents).offset(_index_0 as isize)).symbol
                    as libc::c_int
                    - subgraph_0.symbol as libc::c_int;
                if comparison_0 == 0 as libc::c_int {
                    _exists_0 = 1 as libc::c_int as libc::c_uint;
                } else if comparison_0 < 0 as libc::c_int {
                    _index_0 = _index_0.wrapping_add(1 as libc::c_int as libc::c_uint);
                }
            }
            if _exists_0 == 0 {
                _array__splice(
                    &mut subgraphs as *mut AnalysisSubgraphArray as *mut Array,
                    ::core::mem::size_of::<AnalysisSubgraph>() as libc::c_ulong,
                    _index_0,
                    0 as libc::c_int as uint32_t,
                    1 as libc::c_int as uint32_t,
                    &mut subgraph_0 as *mut AnalysisSubgraph as *const libc::c_void,
                );
            }
        }
        sym = sym.wrapping_add(1);
    }
    let mut predecessor_map: StatePredecessorMap = state_predecessor_map_new((*self_0).language);
    let mut state: TSStateId = 1 as libc::c_int as TSStateId;
    while (state as libc::c_int) < (*(*self_0).language).state_count as uint16_t as libc::c_int {
        let mut subgraph_index: libc::c_uint = 0;
        let mut exists: libc::c_uint = 0;
        let mut lookahead_iterator: LookaheadIterator =
            ts_language_lookaheads((*self_0).language, state);
        while ts_lookahead_iterator__next(&mut lookahead_iterator) {
            if lookahead_iterator.action_count != 0 {
                let mut i_2: libc::c_uint = 0 as libc::c_int as libc::c_uint;
                while i_2 < lookahead_iterator.action_count as libc::c_uint {
                    let mut action: *const TSParseAction =
                        &*(lookahead_iterator.actions).offset(i_2 as isize) as *const TSParseAction;
                    if (*action).type_ as libc::c_int == TSParseActionTypeReduce as libc::c_int {
                        let mut aliases: *const TSSymbol = 0 as *const TSSymbol;
                        let mut aliases_end: *const TSSymbol = 0 as *const TSSymbol;
                        ts_language_aliases_for_symbol(
                            (*self_0).language,
                            (*action).reduce.symbol,
                            &mut aliases,
                            &mut aliases_end,
                        );
                        let mut symbol: *const TSSymbol = aliases;
                        while symbol < aliases_end {
                            subgraph_index = 0 as libc::c_int as libc::c_uint;
                            exists = 0 as libc::c_int as libc::c_uint;
                            let mut size_1: uint32_t =
                                (subgraphs.size).wrapping_sub(subgraph_index);
                            if !(size_1 == 0 as libc::c_int as libc::c_uint) {
                                let mut comparison_1: libc::c_int = 0;
                                while size_1 > 1 as libc::c_int as libc::c_uint {
                                    let mut half_size_1: uint32_t =
                                        size_1.wrapping_div(2 as libc::c_int as libc::c_uint);
                                    let mut mid_index_1: uint32_t =
                                        subgraph_index.wrapping_add(half_size_1);
                                    comparison_1 =
                                        (*(subgraphs.contents).offset(mid_index_1 as isize)).symbol
                                            as libc::c_int
                                            - *symbol as libc::c_int;
                                    if comparison_1 <= 0 as libc::c_int {
                                        subgraph_index = mid_index_1;
                                    }
                                    size_1 = (size_1 as libc::c_uint).wrapping_sub(half_size_1)
                                        as uint32_t
                                        as uint32_t;
                                }
                                comparison_1 =
                                    (*(subgraphs.contents).offset(subgraph_index as isize)).symbol
                                        as libc::c_int
                                        - *symbol as libc::c_int;
                                if comparison_1 == 0 as libc::c_int {
                                    exists = 1 as libc::c_int as libc::c_uint;
                                } else if comparison_1 < 0 as libc::c_int {
                                    subgraph_index = subgraph_index
                                        .wrapping_add(1 as libc::c_int as libc::c_uint);
                                }
                            }
                            if exists != 0 {
                                let mut subgraph_1: *mut AnalysisSubgraph =
                                    &mut *(subgraphs.contents).offset(subgraph_index as isize)
                                        as *mut AnalysisSubgraph;
                                if (*subgraph_1).nodes.size == 0 as libc::c_int as libc::c_uint || {
                                    if ((*subgraph_1).nodes.size)
                                        .wrapping_sub(1 as libc::c_int as libc::c_uint)
                                        < (*subgraph_1).nodes.size
                                    {
                                    } else {
                                        panic!();
                                    }
                                    (*(&mut *((*subgraph_1).nodes.contents).offset(
                                        ((*subgraph_1).nodes.size)
                                            .wrapping_sub(1 as libc::c_int as libc::c_uint)
                                            as isize,
                                    )
                                        as *mut AnalysisSubgraphNode))
                                        .state as libc::c_int
                                        != state as libc::c_int
                                } {
                                    _array__grow(
                                        &mut (*subgraph_1).nodes as *mut C2RustUnnamed_23
                                            as *mut Array,
                                        1 as libc::c_int as uint32_t,
                                        ::core::mem::size_of::<AnalysisSubgraphNode>()
                                            as libc::c_ulong,
                                    );
                                    let fresh12 = (*subgraph_1).nodes.size;
                                    (*subgraph_1).nodes.size =
                                        ((*subgraph_1).nodes.size).wrapping_add(1);
                                    *((*subgraph_1).nodes.contents).offset(fresh12 as isize) = {
                                        let mut init = AnalysisSubgraphNode {
                                            child_index_done: [0; 1],
                                            c2rust_padding: [0; 1],
                                            state: state,
                                            production_id: (*action).reduce.production_id,
                                        };
                                        init.set_child_index((*action).reduce.child_count);
                                        init.set_done(1 as libc::c_int != 0);
                                        init
                                    };
                                }
                            }
                            symbol = symbol.offset(1);
                        }
                    } else if (*action).type_ as libc::c_int
                        == TSParseActionTypeShift as libc::c_int
                        && !(*action).shift.extra
                    {
                        let mut next_state: TSStateId = (*action).shift.state;
                        state_predecessor_map_add(&mut predecessor_map, next_state, state);
                    }
                    i_2 = i_2.wrapping_add(1);
                }
            } else if lookahead_iterator.next_state as libc::c_int != 0 as libc::c_int {
                if lookahead_iterator.next_state as libc::c_int != state as libc::c_int {
                    state_predecessor_map_add(
                        &mut predecessor_map,
                        lookahead_iterator.next_state,
                        state,
                    );
                }
                if ts_language_state_is_primary((*self_0).language, state) {
                    let mut aliases_0: *const TSSymbol = 0 as *const TSSymbol;
                    let mut aliases_end_0: *const TSSymbol = 0 as *const TSSymbol;
                    ts_language_aliases_for_symbol(
                        (*self_0).language,
                        lookahead_iterator.symbol,
                        &mut aliases_0,
                        &mut aliases_end_0,
                    );
                    let mut symbol_0: *const TSSymbol = aliases_0;
                    while symbol_0 < aliases_end_0 {
                        subgraph_index = 0 as libc::c_int as libc::c_uint;
                        exists = 0 as libc::c_int as libc::c_uint;
                        let mut size_2: uint32_t = (subgraphs.size).wrapping_sub(subgraph_index);
                        if !(size_2 == 0 as libc::c_int as libc::c_uint) {
                            let mut comparison_2: libc::c_int = 0;
                            while size_2 > 1 as libc::c_int as libc::c_uint {
                                let mut half_size_2: uint32_t =
                                    size_2.wrapping_div(2 as libc::c_int as libc::c_uint);
                                let mut mid_index_2: uint32_t =
                                    subgraph_index.wrapping_add(half_size_2);
                                comparison_2 = (*(subgraphs.contents).offset(mid_index_2 as isize))
                                    .symbol
                                    as libc::c_int
                                    - *symbol_0 as libc::c_int;
                                if comparison_2 <= 0 as libc::c_int {
                                    subgraph_index = mid_index_2;
                                }
                                size_2 = (size_2 as libc::c_uint).wrapping_sub(half_size_2)
                                    as uint32_t
                                    as uint32_t;
                            }
                            comparison_2 = (*(subgraphs.contents).offset(subgraph_index as isize))
                                .symbol as libc::c_int
                                - *symbol_0 as libc::c_int;
                            if comparison_2 == 0 as libc::c_int {
                                exists = 1 as libc::c_int as libc::c_uint;
                            } else if comparison_2 < 0 as libc::c_int {
                                subgraph_index =
                                    subgraph_index.wrapping_add(1 as libc::c_int as libc::c_uint);
                            }
                        }
                        if exists != 0 {
                            let mut subgraph_2: *mut AnalysisSubgraph = &mut *(subgraphs.contents)
                                .offset(subgraph_index as isize)
                                as *mut AnalysisSubgraph;
                            if (*subgraph_2).start_states.size == 0 as libc::c_int as libc::c_uint
                                || {
                                    if ((*subgraph_2).start_states.size)
                                        .wrapping_sub(1 as libc::c_int as libc::c_uint)
                                        < (*subgraph_2).start_states.size
                                    {
                                    } else {
                                        panic!();
                                    }
                                    *(&mut *((*subgraph_2).start_states.contents).offset(
                                        ((*subgraph_2).start_states.size)
                                            .wrapping_sub(1 as libc::c_int as libc::c_uint)
                                            as isize,
                                    ) as *mut TSStateId)
                                        as libc::c_int
                                        != state as libc::c_int
                                }
                            {
                                _array__grow(
                                    &mut (*subgraph_2).start_states as *mut C2RustUnnamed_24
                                        as *mut Array,
                                    1 as libc::c_int as uint32_t,
                                    ::core::mem::size_of::<TSStateId>() as libc::c_ulong,
                                );
                                let fresh13 = (*subgraph_2).start_states.size;
                                (*subgraph_2).start_states.size =
                                    ((*subgraph_2).start_states.size).wrapping_add(1);
                                *((*subgraph_2).start_states.contents).offset(fresh13 as isize) =
                                    state;
                            }
                        }
                        symbol_0 = symbol_0.offset(1);
                    }
                }
            }
        }
        state = state.wrapping_add(1);
    }
    let mut next_nodes: C2RustUnnamed_20 = {
        let mut init = C2RustUnnamed_20 {
            contents: 0 as *mut AnalysisSubgraphNode,
            size: 0 as libc::c_int as uint32_t,
            capacity: 0 as libc::c_int as uint32_t,
        };
        init
    };
    let mut i_3: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i_3 < subgraphs.size {
        let mut subgraph_3: *mut AnalysisSubgraph =
            &mut *(subgraphs.contents).offset(i_3 as isize) as *mut AnalysisSubgraph;
        if (*subgraph_3).nodes.size == 0 as libc::c_int as libc::c_uint {
            _array__delete(&mut (*subgraph_3).start_states as *mut C2RustUnnamed_24 as *mut Array);
            _array__erase(
                &mut subgraphs as *mut AnalysisSubgraphArray as *mut Array,
                ::core::mem::size_of::<AnalysisSubgraph>() as libc::c_ulong,
                i_3,
            );
            i_3 = i_3.wrapping_sub(1);
        } else {
            _array__assign(
                &mut next_nodes as *mut C2RustUnnamed_20 as *mut Array,
                &mut (*subgraph_3).nodes as *mut C2RustUnnamed_23 as *const Array,
                ::core::mem::size_of::<AnalysisSubgraphNode>() as libc::c_ulong,
            );
            while next_nodes.size > 0 as libc::c_int as libc::c_uint {
                next_nodes.size = (next_nodes.size).wrapping_sub(1);
                let mut node: AnalysisSubgraphNode =
                    *(next_nodes.contents).offset(next_nodes.size as isize);
                if node.child_index() as libc::c_int > 1 as libc::c_int {
                    let mut predecessor_count: libc::c_uint = 0;
                    let mut predecessors: *const TSStateId = state_predecessor_map_get(
                        &mut predecessor_map,
                        node.state,
                        &mut predecessor_count,
                    );
                    let mut j_0: libc::c_uint = 0 as libc::c_int as libc::c_uint;
                    while j_0 < predecessor_count {
                        let mut predecessor_node: AnalysisSubgraphNode = {
                            let mut init = AnalysisSubgraphNode {
                                child_index_done: [0; 1],
                                c2rust_padding: [0; 1],
                                state: *predecessors.offset(j_0 as isize),
                                production_id: node.production_id,
                            };
                            init.set_child_index(
                                (node.child_index() as libc::c_int - 1 as libc::c_int) as uint8_t,
                            );
                            init.set_done(0 as libc::c_int != 0);
                            init
                        };
                        let mut index: libc::c_uint = 0;
                        let mut exists_0: libc::c_uint = 0;
                        index = 0 as libc::c_int as libc::c_uint;
                        exists_0 = 0 as libc::c_int as libc::c_uint;
                        let mut size_3: uint32_t = ((*subgraph_3).nodes.size).wrapping_sub(index);
                        if !(size_3 == 0 as libc::c_int as libc::c_uint) {
                            let mut comparison_3: libc::c_int = 0;
                            while size_3 > 1 as libc::c_int as libc::c_uint {
                                let mut half_size_3: uint32_t =
                                    size_3.wrapping_div(2 as libc::c_int as libc::c_uint);
                                let mut mid_index_3: uint32_t = index.wrapping_add(half_size_3);
                                comparison_3 = analysis_subgraph_node__compare(
                                    &mut *((*subgraph_3).nodes.contents)
                                        .offset(mid_index_3 as isize),
                                    &mut predecessor_node,
                                );
                                if comparison_3 <= 0 as libc::c_int {
                                    index = mid_index_3;
                                }
                                size_3 = (size_3 as libc::c_uint).wrapping_sub(half_size_3)
                                    as uint32_t
                                    as uint32_t;
                            }
                            comparison_3 = analysis_subgraph_node__compare(
                                &mut *((*subgraph_3).nodes.contents).offset(index as isize),
                                &mut predecessor_node,
                            );
                            if comparison_3 == 0 as libc::c_int {
                                exists_0 = 1 as libc::c_int as libc::c_uint;
                            } else if comparison_3 < 0 as libc::c_int {
                                index = index.wrapping_add(1 as libc::c_int as libc::c_uint);
                            }
                        }
                        if exists_0 == 0 {
                            _array__splice(
                                &mut (*subgraph_3).nodes as *mut C2RustUnnamed_23 as *mut Array,
                                ::core::mem::size_of::<AnalysisSubgraphNode>() as libc::c_ulong,
                                index,
                                0 as libc::c_int as uint32_t,
                                1 as libc::c_int as uint32_t,
                                &mut predecessor_node as *mut AnalysisSubgraphNode
                                    as *const libc::c_void,
                            );
                            _array__grow(
                                &mut next_nodes as *mut C2RustUnnamed_20 as *mut Array,
                                1 as libc::c_int as uint32_t,
                                ::core::mem::size_of::<AnalysisSubgraphNode>() as libc::c_ulong,
                            );
                            let fresh14 = next_nodes.size;
                            next_nodes.size = (next_nodes.size).wrapping_add(1);
                            *(next_nodes.contents).offset(fresh14 as isize) = predecessor_node;
                        }
                        j_0 = j_0.wrapping_add(1);
                    }
                }
            }
        }
        i_3 = i_3.wrapping_add(1);
    }
    let mut all_patterns_are_valid: bool = 1 as libc::c_int != 0;
    let mut analysis: QueryAnalysis = query_analysis__new();
    let mut i_4: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i_4 < parent_step_indices.size {
        let mut parent_step_index_0: uint16_t =
            *(parent_step_indices.contents).offset(i_4 as isize) as uint16_t;
        let mut parent_depth: uint16_t =
            (*((*self_0).steps.contents).offset(parent_step_index_0 as isize)).depth;
        let mut parent_symbol_0: TSSymbol =
            (*((*self_0).steps.contents).offset(parent_step_index_0 as isize)).symbol;
        if !(parent_symbol_0 as libc::c_int == -(1 as libc::c_int) as TSSymbol as libc::c_int) {
            let mut subgraph_index_0: libc::c_uint = 0;
            let mut exists_1: libc::c_uint = 0;
            subgraph_index_0 = 0 as libc::c_int as libc::c_uint;
            exists_1 = 0 as libc::c_int as libc::c_uint;
            let mut size_4: uint32_t = (subgraphs.size).wrapping_sub(subgraph_index_0);
            if !(size_4 == 0 as libc::c_int as libc::c_uint) {
                let mut comparison_4: libc::c_int = 0;
                while size_4 > 1 as libc::c_int as libc::c_uint {
                    let mut half_size_4: uint32_t =
                        size_4.wrapping_div(2 as libc::c_int as libc::c_uint);
                    let mut mid_index_4: uint32_t = subgraph_index_0.wrapping_add(half_size_4);
                    comparison_4 = (*(subgraphs.contents).offset(mid_index_4 as isize)).symbol
                        as libc::c_int
                        - parent_symbol_0 as libc::c_int;
                    if comparison_4 <= 0 as libc::c_int {
                        subgraph_index_0 = mid_index_4;
                    }
                    size_4 =
                        (size_4 as libc::c_uint).wrapping_sub(half_size_4) as uint32_t as uint32_t;
                }
                comparison_4 = (*(subgraphs.contents).offset(subgraph_index_0 as isize)).symbol
                    as libc::c_int
                    - parent_symbol_0 as libc::c_int;
                if comparison_4 == 0 as libc::c_int {
                    exists_1 = 1 as libc::c_int as libc::c_uint;
                } else if comparison_4 < 0 as libc::c_int {
                    subgraph_index_0 =
                        subgraph_index_0.wrapping_add(1 as libc::c_int as libc::c_uint);
                }
            }
            if exists_1 == 0 {
                let mut first_child_step_index: libc::c_uint =
                    (parent_step_index_0 as libc::c_int + 1 as libc::c_int) as libc::c_uint;
                let mut j_1: uint32_t = 0;
                let mut child_exists: uint32_t = 0;
                j_1 = 0 as libc::c_int as uint32_t;
                child_exists = 0 as libc::c_int as uint32_t;
                let mut size_5: uint32_t = ((*self_0).step_offsets.size).wrapping_sub(j_1);
                if !(size_5 == 0 as libc::c_int as libc::c_uint) {
                    let mut comparison_5: libc::c_int = 0;
                    while size_5 > 1 as libc::c_int as libc::c_uint {
                        let mut half_size_5: uint32_t =
                            size_5.wrapping_div(2 as libc::c_int as libc::c_uint);
                        let mut mid_index_5: uint32_t = j_1.wrapping_add(half_size_5);
                        comparison_5 = (*((*self_0).step_offsets.contents)
                            .offset(mid_index_5 as isize))
                        .step_index as libc::c_int
                            - first_child_step_index as libc::c_int;
                        if comparison_5 <= 0 as libc::c_int {
                            j_1 = mid_index_5;
                        }
                        size_5 = (size_5 as libc::c_uint).wrapping_sub(half_size_5) as uint32_t
                            as uint32_t;
                    }
                    comparison_5 = (*((*self_0).step_offsets.contents).offset(j_1 as isize))
                        .step_index as libc::c_int
                        - first_child_step_index as libc::c_int;
                    if comparison_5 == 0 as libc::c_int {
                        child_exists = 1 as libc::c_int as uint32_t;
                    } else if comparison_5 < 0 as libc::c_int {
                        j_1 = (j_1 as libc::c_uint).wrapping_add(1 as libc::c_int as libc::c_uint)
                            as uint32_t as uint32_t;
                    }
                }
                if child_exists != 0 {
                } else {
                    panic!();
                }
                *error_offset =
                    (*((*self_0).step_offsets.contents).offset(j_1 as isize)).byte_offset;
                all_patterns_are_valid = 0 as libc::c_int != 0;
                break;
            } else {
                let mut subgraph_4: *mut AnalysisSubgraph = &mut *(subgraphs.contents)
                    .offset(subgraph_index_0 as isize)
                    as *mut AnalysisSubgraph;
                analysis_state_set__clear(&mut analysis.states, &mut analysis.state_pool);
                analysis_state_set__clear(&mut analysis.deeper_states, &mut analysis.state_pool);
                let mut j_2: libc::c_uint = 0 as libc::c_int as libc::c_uint;
                while j_2 < (*subgraph_4).start_states.size {
                    let mut parse_state: TSStateId =
                        *((*subgraph_4).start_states.contents).offset(j_2 as isize);
                    analysis_state_set__push(
                        &mut analysis.states,
                        &mut analysis.state_pool,
                        &mut {
                            let mut init = AnalysisState {
                                stack: [
                                    {
                                        let mut init = AnalysisStateEntry {
                                            field_id_done: [0; 2],
                                            parse_state: parse_state,
                                            parent_symbol: parent_symbol_0,
                                            child_index: 0 as libc::c_int as uint16_t,
                                        };
                                        init.set_field_id(0 as libc::c_int as TSFieldId);
                                        init.set_done(0 as libc::c_int != 0);
                                        init
                                    },
                                    AnalysisStateEntry {
                                        parse_state: 0,
                                        parent_symbol: 0,
                                        child_index: 0,
                                        field_id_done: [0; 2],
                                    },
                                    AnalysisStateEntry {
                                        parse_state: 0,
                                        parent_symbol: 0,
                                        child_index: 0,
                                        field_id_done: [0; 2],
                                    },
                                    AnalysisStateEntry {
                                        parse_state: 0,
                                        parent_symbol: 0,
                                        child_index: 0,
                                        field_id_done: [0; 2],
                                    },
                                    AnalysisStateEntry {
                                        parse_state: 0,
                                        parent_symbol: 0,
                                        child_index: 0,
                                        field_id_done: [0; 2],
                                    },
                                    AnalysisStateEntry {
                                        parse_state: 0,
                                        parent_symbol: 0,
                                        child_index: 0,
                                        field_id_done: [0; 2],
                                    },
                                    AnalysisStateEntry {
                                        parse_state: 0,
                                        parent_symbol: 0,
                                        child_index: 0,
                                        field_id_done: [0; 2],
                                    },
                                    AnalysisStateEntry {
                                        parse_state: 0,
                                        parent_symbol: 0,
                                        child_index: 0,
                                        field_id_done: [0; 2],
                                    },
                                ],
                                depth: 1 as libc::c_int as uint16_t,
                                step_index: (parent_step_index_0 as libc::c_int + 1 as libc::c_int)
                                    as uint16_t,
                                root_symbol: parent_symbol_0,
                            };
                            init
                        },
                    );
                    j_2 = j_2.wrapping_add(1);
                }
                analysis.did_abort = 0 as libc::c_int != 0;
                ts_query__perform_analysis(self_0, &mut subgraphs, &mut analysis);
                if analysis.did_abort {
                    let mut j_3: libc::c_uint =
                        (parent_step_index_0 as libc::c_int + 1 as libc::c_int) as libc::c_uint;
                    while j_3 < (*self_0).steps.size {
                        let mut step_1: *mut QueryStep =
                            &mut *((*self_0).steps.contents).offset(j_3 as isize) as *mut QueryStep;
                        if (*step_1).depth as libc::c_int <= parent_depth as libc::c_int
                            || (*step_1).depth as libc::c_int == PATTERN_DONE_MARKER as libc::c_int
                        {
                            break;
                        }
                        if !(*step_1).is_dead_end() {
                            (*step_1).set_parent_pattern_guaranteed(0 as libc::c_int != 0);
                            (*step_1).set_root_pattern_guaranteed(0 as libc::c_int != 0);
                        }
                        j_3 = j_3.wrapping_add(1);
                    }
                } else if analysis.finished_parent_symbols.size == 0 as libc::c_int as libc::c_uint
                {
                    if analysis.final_step_indices.size > 0 as libc::c_int as libc::c_uint {
                    } else {
                        panic!();
                    }
                    if (analysis.final_step_indices.size)
                        .wrapping_sub(1 as libc::c_int as libc::c_uint)
                        < analysis.final_step_indices.size
                    {
                    } else {
                        panic!();
                    }
                    let mut impossible_step_index: uint16_t =
                        *(&mut *(analysis.final_step_indices.contents).offset(
                            (analysis.final_step_indices.size)
                                .wrapping_sub(1 as libc::c_int as libc::c_uint)
                                as isize,
                        ) as *mut uint16_t);
                    let mut j_4: uint32_t = 0;
                    let mut impossible_exists: uint32_t = 0;
                    j_4 = 0 as libc::c_int as uint32_t;
                    impossible_exists = 0 as libc::c_int as uint32_t;
                    let mut size_6: uint32_t = ((*self_0).step_offsets.size).wrapping_sub(j_4);
                    if !(size_6 == 0 as libc::c_int as libc::c_uint) {
                        let mut comparison_6: libc::c_int = 0;
                        while size_6 > 1 as libc::c_int as libc::c_uint {
                            let mut half_size_6: uint32_t =
                                size_6.wrapping_div(2 as libc::c_int as libc::c_uint);
                            let mut mid_index_6: uint32_t = j_4.wrapping_add(half_size_6);
                            comparison_6 = (*((*self_0).step_offsets.contents)
                                .offset(mid_index_6 as isize))
                            .step_index as libc::c_int
                                - impossible_step_index as libc::c_int;
                            if comparison_6 <= 0 as libc::c_int {
                                j_4 = mid_index_6;
                            }
                            size_6 = (size_6 as libc::c_uint).wrapping_sub(half_size_6) as uint32_t
                                as uint32_t;
                        }
                        comparison_6 = (*((*self_0).step_offsets.contents).offset(j_4 as isize))
                            .step_index as libc::c_int
                            - impossible_step_index as libc::c_int;
                        if comparison_6 == 0 as libc::c_int {
                            impossible_exists = 1 as libc::c_int as uint32_t;
                        } else if comparison_6 < 0 as libc::c_int {
                            j_4 = (j_4 as libc::c_uint)
                                .wrapping_add(1 as libc::c_int as libc::c_uint)
                                as uint32_t as uint32_t;
                        }
                    }
                    if j_4 >= (*self_0).step_offsets.size {
                        j_4 = ((*self_0).step_offsets.size)
                            .wrapping_sub(1 as libc::c_int as libc::c_uint);
                    }
                    *error_offset =
                        (*((*self_0).step_offsets.contents).offset(j_4 as isize)).byte_offset;
                    all_patterns_are_valid = 0 as libc::c_int != 0;
                    break;
                } else {
                    let mut j_5: libc::c_uint = 0 as libc::c_int as libc::c_uint;
                    while j_5 < analysis.final_step_indices.size {
                        let mut final_step_index: uint32_t = *(analysis.final_step_indices.contents)
                            .offset(j_5 as isize)
                            as uint32_t;
                        let mut step_2: *mut QueryStep = &mut *((*self_0).steps.contents)
                            .offset(final_step_index as isize)
                            as *mut QueryStep;
                        if (*step_2).depth as libc::c_int != PATTERN_DONE_MARKER as libc::c_int
                            && (*step_2).depth as libc::c_int > parent_depth as libc::c_int
                            && !(*step_2).is_dead_end()
                        {
                            (*step_2).set_parent_pattern_guaranteed(0 as libc::c_int != 0);
                            (*step_2).set_root_pattern_guaranteed(0 as libc::c_int != 0);
                        }
                        j_5 = j_5.wrapping_add(1);
                    }
                }
            }
        }
        i_4 = i_4.wrapping_add(1);
    }
    let mut predicate_capture_ids: C2RustUnnamed_17 = {
        let mut init = C2RustUnnamed_17 {
            contents: 0 as *mut uint16_t,
            size: 0 as libc::c_int as uint32_t,
            capacity: 0 as libc::c_int as uint32_t,
        };
        init
    };
    let mut i_5: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i_5 < (*self_0).patterns.size {
        let mut pattern_0: *mut QueryPattern =
            &mut *((*self_0).patterns.contents).offset(i_5 as isize) as *mut QueryPattern;
        predicate_capture_ids.size = 0 as libc::c_int as uint32_t;
        let mut start: libc::c_uint = (*pattern_0).predicate_steps.offset;
        let mut end: libc::c_uint = start.wrapping_add((*pattern_0).predicate_steps.length);
        let mut j_6: libc::c_uint = start;
        while j_6 < end {
            let mut step_3: *mut TSQueryPredicateStep = &mut *((*self_0).predicate_steps.contents)
                .offset(j_6 as isize)
                as *mut TSQueryPredicateStep;
            if (*step_3).type_ as libc::c_uint
                == TSQueryPredicateStepTypeCapture as libc::c_int as libc::c_uint
            {
                let mut value_id: uint16_t = (*step_3).value_id as uint16_t;
                let mut _index_1: libc::c_uint = 0;
                let mut _exists_1: libc::c_uint = 0;
                _index_1 = 0 as libc::c_int as libc::c_uint;
                _exists_1 = 0 as libc::c_int as libc::c_uint;
                let mut size_7: uint32_t = (predicate_capture_ids.size).wrapping_sub(_index_1);
                if !(size_7 == 0 as libc::c_int as libc::c_uint) {
                    let mut comparison_7: libc::c_int = 0;
                    while size_7 > 1 as libc::c_int as libc::c_uint {
                        let mut half_size_7: uint32_t =
                            size_7.wrapping_div(2 as libc::c_int as libc::c_uint);
                        let mut mid_index_7: uint32_t = _index_1.wrapping_add(half_size_7);
                        comparison_7 = *(predicate_capture_ids.contents)
                            .offset(mid_index_7 as isize)
                            as libc::c_int
                            - value_id as libc::c_int;
                        if comparison_7 <= 0 as libc::c_int {
                            _index_1 = mid_index_7;
                        }
                        size_7 = (size_7 as libc::c_uint).wrapping_sub(half_size_7) as uint32_t
                            as uint32_t;
                    }
                    comparison_7 = *(predicate_capture_ids.contents).offset(_index_1 as isize)
                        as libc::c_int
                        - value_id as libc::c_int;
                    if comparison_7 == 0 as libc::c_int {
                        _exists_1 = 1 as libc::c_int as libc::c_uint;
                    } else if comparison_7 < 0 as libc::c_int {
                        _index_1 = _index_1.wrapping_add(1 as libc::c_int as libc::c_uint);
                    }
                }
                if _exists_1 == 0 {
                    _array__splice(
                        &mut predicate_capture_ids as *mut C2RustUnnamed_17 as *mut Array,
                        ::core::mem::size_of::<uint16_t>() as libc::c_ulong,
                        _index_1,
                        0 as libc::c_int as uint32_t,
                        1 as libc::c_int as uint32_t,
                        &mut value_id as *mut uint16_t as *const libc::c_void,
                    );
                }
            }
            j_6 = j_6.wrapping_add(1);
        }
        let mut start_0: libc::c_uint = (*pattern_0).steps.offset;
        let mut end_0: libc::c_uint = start_0.wrapping_add((*pattern_0).steps.length);
        let mut j_7: libc::c_uint = start_0;
        while j_7 < end_0 {
            let mut step_4: *mut QueryStep =
                &mut *((*self_0).steps.contents).offset(j_7 as isize) as *mut QueryStep;
            let mut k: libc::c_uint = 0 as libc::c_int as libc::c_uint;
            while k < 3 as libc::c_int as libc::c_uint {
                let mut capture_id: uint16_t = (*step_4).capture_ids[k as usize];
                if capture_id as libc::c_int == NONE as libc::c_int {
                    break;
                }
                let mut index_0: libc::c_uint = 0;
                let mut exists_2: libc::c_uint = 0;
                index_0 = 0 as libc::c_int as libc::c_uint;
                exists_2 = 0 as libc::c_int as libc::c_uint;
                let mut size_8: uint32_t = (predicate_capture_ids.size).wrapping_sub(index_0);
                if !(size_8 == 0 as libc::c_int as libc::c_uint) {
                    let mut comparison_8: libc::c_int = 0;
                    while size_8 > 1 as libc::c_int as libc::c_uint {
                        let mut half_size_8: uint32_t =
                            size_8.wrapping_div(2 as libc::c_int as libc::c_uint);
                        let mut mid_index_8: uint32_t = index_0.wrapping_add(half_size_8);
                        comparison_8 = *(predicate_capture_ids.contents)
                            .offset(mid_index_8 as isize)
                            as libc::c_int
                            - capture_id as libc::c_int;
                        if comparison_8 <= 0 as libc::c_int {
                            index_0 = mid_index_8;
                        }
                        size_8 = (size_8 as libc::c_uint).wrapping_sub(half_size_8) as uint32_t
                            as uint32_t;
                    }
                    comparison_8 = *(predicate_capture_ids.contents).offset(index_0 as isize)
                        as libc::c_int
                        - capture_id as libc::c_int;
                    if comparison_8 == 0 as libc::c_int {
                        exists_2 = 1 as libc::c_int as libc::c_uint;
                    } else if comparison_8 < 0 as libc::c_int {
                        index_0 = index_0.wrapping_add(1 as libc::c_int as libc::c_uint);
                    }
                }
                if exists_2 != 0 {
                    (*step_4).set_root_pattern_guaranteed(0 as libc::c_int != 0);
                    break;
                } else {
                    k = k.wrapping_add(1);
                }
            }
            j_7 = j_7.wrapping_add(1);
        }
        i_5 = i_5.wrapping_add(1);
    }
    let mut done: bool = (*self_0).steps.size == 0 as libc::c_int as libc::c_uint;
    while !done {
        done = 1 as libc::c_int != 0;
        let mut i_6: libc::c_uint =
            ((*self_0).steps.size).wrapping_sub(1 as libc::c_int as libc::c_uint);
        while i_6 > 0 as libc::c_int as libc::c_uint {
            let mut step_5: *mut QueryStep =
                &mut *((*self_0).steps.contents).offset(i_6 as isize) as *mut QueryStep;
            if !((*step_5).depth as libc::c_int == PATTERN_DONE_MARKER as libc::c_int) {
                let mut parent_pattern_guaranteed: bool = 0 as libc::c_int != 0;
                loop {
                    if (*step_5).root_pattern_guaranteed() {
                        parent_pattern_guaranteed = 1 as libc::c_int != 0;
                        break;
                    } else {
                        if (*step_5).alternative_index as libc::c_int == NONE as libc::c_int
                            || ((*step_5).alternative_index as libc::c_uint) < i_6
                        {
                            break;
                        }
                        step_5 = &mut *((*self_0).steps.contents)
                            .offset((*step_5).alternative_index as isize)
                            as *mut QueryStep;
                    }
                }
                if !parent_pattern_guaranteed {
                    let mut prev_step: *mut QueryStep = &mut *((*self_0).steps.contents)
                        .offset(i_6.wrapping_sub(1 as libc::c_int as libc::c_uint) as isize)
                        as *mut QueryStep;
                    if !(*prev_step).is_dead_end()
                        && (*prev_step).depth as libc::c_int != PATTERN_DONE_MARKER as libc::c_int
                        && (*prev_step).root_pattern_guaranteed() as libc::c_int != 0
                    {
                        (*prev_step).set_root_pattern_guaranteed(0 as libc::c_int != 0);
                        done = 0 as libc::c_int != 0;
                    }
                }
            }
            i_6 = i_6.wrapping_sub(1);
        }
    }
    analysis.did_abort = 0 as libc::c_int != 0;
    let mut i_7: uint32_t = 0 as libc::c_int as uint32_t;
    while i_7 < non_rooted_pattern_start_steps.size {
        let mut pattern_entry_index: uint16_t =
            *(non_rooted_pattern_start_steps.contents).offset(i_7 as isize);
        let mut pattern_entry: *mut PatternEntry = &mut *((*self_0).pattern_map.contents)
            .offset(pattern_entry_index as isize)
            as *mut PatternEntry;
        analysis_state_set__clear(&mut analysis.states, &mut analysis.state_pool);
        analysis_state_set__clear(&mut analysis.deeper_states, &mut analysis.state_pool);
        let mut j_8: libc::c_uint = 0 as libc::c_int as libc::c_uint;
        while j_8 < subgraphs.size {
            let mut subgraph_5: *mut AnalysisSubgraph =
                &mut *(subgraphs.contents).offset(j_8 as isize) as *mut AnalysisSubgraph;
            let mut metadata: TSSymbolMetadata =
                ts_language_symbol_metadata((*self_0).language, (*subgraph_5).symbol);
            if !(metadata.visible as libc::c_int != 0 || metadata.named as libc::c_int != 0) {
                let mut k_0: uint32_t = 0 as libc::c_int as uint32_t;
                while k_0 < (*subgraph_5).start_states.size {
                    let mut parse_state_0: TSStateId =
                        *((*subgraph_5).start_states.contents).offset(k_0 as isize);
                    analysis_state_set__push(
                        &mut analysis.states,
                        &mut analysis.state_pool,
                        &mut {
                            let mut init = AnalysisState {
                                stack: [
                                    {
                                        let mut init = AnalysisStateEntry {
                                            field_id_done: [0; 2],
                                            parse_state: parse_state_0,
                                            parent_symbol: (*subgraph_5).symbol,
                                            child_index: 0 as libc::c_int as uint16_t,
                                        };
                                        init.set_field_id(0 as libc::c_int as TSFieldId);
                                        init.set_done(0 as libc::c_int != 0);
                                        init
                                    },
                                    AnalysisStateEntry {
                                        parse_state: 0,
                                        parent_symbol: 0,
                                        child_index: 0,
                                        field_id_done: [0; 2],
                                    },
                                    AnalysisStateEntry {
                                        parse_state: 0,
                                        parent_symbol: 0,
                                        child_index: 0,
                                        field_id_done: [0; 2],
                                    },
                                    AnalysisStateEntry {
                                        parse_state: 0,
                                        parent_symbol: 0,
                                        child_index: 0,
                                        field_id_done: [0; 2],
                                    },
                                    AnalysisStateEntry {
                                        parse_state: 0,
                                        parent_symbol: 0,
                                        child_index: 0,
                                        field_id_done: [0; 2],
                                    },
                                    AnalysisStateEntry {
                                        parse_state: 0,
                                        parent_symbol: 0,
                                        child_index: 0,
                                        field_id_done: [0; 2],
                                    },
                                    AnalysisStateEntry {
                                        parse_state: 0,
                                        parent_symbol: 0,
                                        child_index: 0,
                                        field_id_done: [0; 2],
                                    },
                                    AnalysisStateEntry {
                                        parse_state: 0,
                                        parent_symbol: 0,
                                        child_index: 0,
                                        field_id_done: [0; 2],
                                    },
                                ],
                                depth: 1 as libc::c_int as uint16_t,
                                step_index: (*pattern_entry).step_index,
                                root_symbol: (*subgraph_5).symbol,
                            };
                            init
                        },
                    );
                    k_0 = k_0.wrapping_add(1);
                }
            }
            j_8 = j_8.wrapping_add(1);
        }
        ts_query__perform_analysis(self_0, &mut subgraphs, &mut analysis);
        if analysis.finished_parent_symbols.size > 0 as libc::c_int as libc::c_uint {
            (*((*self_0).patterns.contents).offset((*pattern_entry).pattern_index as isize))
                .is_non_local = 1 as libc::c_int != 0;
        }
        let mut k_1: libc::c_uint = 0 as libc::c_int as libc::c_uint;
        while k_1 < analysis.finished_parent_symbols.size {
            let mut symbol_1: TSSymbol =
                *(analysis.finished_parent_symbols.contents).offset(k_1 as isize);
            let mut _index_2: libc::c_uint = 0;
            let mut _exists_2: libc::c_uint = 0;
            _index_2 = 0 as libc::c_int as libc::c_uint;
            _exists_2 = 0 as libc::c_int as libc::c_uint;
            let mut size_9: uint32_t =
                ((*self_0).repeat_symbols_with_rootless_patterns.size).wrapping_sub(_index_2);
            if !(size_9 == 0 as libc::c_int as libc::c_uint) {
                let mut comparison_9: libc::c_int = 0;
                while size_9 > 1 as libc::c_int as libc::c_uint {
                    let mut half_size_9: uint32_t =
                        size_9.wrapping_div(2 as libc::c_int as libc::c_uint);
                    let mut mid_index_9: uint32_t = _index_2.wrapping_add(half_size_9);
                    comparison_9 = *((*self_0).repeat_symbols_with_rootless_patterns.contents)
                        .offset(mid_index_9 as isize)
                        as libc::c_int
                        - symbol_1 as libc::c_int;
                    if comparison_9 <= 0 as libc::c_int {
                        _index_2 = mid_index_9;
                    }
                    size_9 =
                        (size_9 as libc::c_uint).wrapping_sub(half_size_9) as uint32_t as uint32_t;
                }
                comparison_9 = *((*self_0).repeat_symbols_with_rootless_patterns.contents)
                    .offset(_index_2 as isize) as libc::c_int
                    - symbol_1 as libc::c_int;
                if comparison_9 == 0 as libc::c_int {
                    _exists_2 = 1 as libc::c_int as libc::c_uint;
                } else if comparison_9 < 0 as libc::c_int {
                    _index_2 = _index_2.wrapping_add(1 as libc::c_int as libc::c_uint);
                }
            }
            if _exists_2 == 0 {
                _array__splice(
                    &mut (*self_0).repeat_symbols_with_rootless_patterns as *mut C2RustUnnamed_3
                        as *mut Array,
                    ::core::mem::size_of::<TSSymbol>() as libc::c_ulong,
                    _index_2,
                    0 as libc::c_int as uint32_t,
                    1 as libc::c_int as uint32_t,
                    &mut symbol_1 as *mut TSSymbol as *const libc::c_void,
                );
            }
            k_1 = k_1.wrapping_add(1);
        }
        i_7 = i_7.wrapping_add(1);
    }
    let mut i_8: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i_8 < subgraphs.size {
        _array__delete(
            &mut (*(subgraphs.contents).offset(i_8 as isize)).start_states as *mut C2RustUnnamed_24
                as *mut Array,
        );
        _array__delete(
            &mut (*(subgraphs.contents).offset(i_8 as isize)).nodes as *mut C2RustUnnamed_23
                as *mut Array,
        );
        i_8 = i_8.wrapping_add(1);
    }
    _array__delete(&mut subgraphs as *mut AnalysisSubgraphArray as *mut Array);
    query_analysis__delete(&mut analysis);
    _array__delete(&mut next_nodes as *mut C2RustUnnamed_20 as *mut Array);
    _array__delete(&mut non_rooted_pattern_start_steps as *mut C2RustUnnamed_19 as *mut Array);
    _array__delete(&mut parent_step_indices as *mut C2RustUnnamed_18 as *mut Array);
    _array__delete(&mut predicate_capture_ids as *mut C2RustUnnamed_17 as *mut Array);
    state_predecessor_map_delete(&mut predecessor_map);
    return all_patterns_are_valid;
}
unsafe extern "C" fn ts_query__add_negated_fields(
    mut self_0: *mut TSQuery,
    mut step_index: uint16_t,
    mut field_ids: *mut TSFieldId,
    mut field_count: uint16_t,
) {
    let mut step: *mut QueryStep =
        &mut *((*self_0).steps.contents).offset(step_index as isize) as *mut QueryStep;
    let mut failed_match: bool = 0 as libc::c_int != 0;
    let mut match_count: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    let mut start_i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i < (*self_0).negated_fields.size {
        let mut existing_field_id: TSFieldId =
            *((*self_0).negated_fields.contents).offset(i as isize);
        if existing_field_id as libc::c_int == 0 as libc::c_int {
            if match_count == field_count as libc::c_uint {
                (*step).negated_field_list_id = start_i as uint16_t;
                return;
            } else {
                start_i = i.wrapping_add(1 as libc::c_int as libc::c_uint);
                match_count = 0 as libc::c_int as libc::c_uint;
                failed_match = 0 as libc::c_int != 0;
            }
        } else if match_count < field_count as libc::c_uint
            && existing_field_id as libc::c_int
                == *field_ids.offset(match_count as isize) as libc::c_int
            && !failed_match
        {
            match_count = match_count.wrapping_add(1);
        } else {
            match_count = 0 as libc::c_int as libc::c_uint;
            failed_match = 1 as libc::c_int != 0;
        }
        i = i.wrapping_add(1);
    }
    (*step).negated_field_list_id = (*self_0).negated_fields.size as uint16_t;
    _array__splice(
        &mut (*self_0).negated_fields as *mut C2RustUnnamed_5 as *mut Array,
        ::core::mem::size_of::<TSFieldId>() as libc::c_ulong,
        (*self_0).negated_fields.size,
        0 as libc::c_int as uint32_t,
        field_count as uint32_t,
        field_ids as *const libc::c_void,
    );
    _array__grow(
        &mut (*self_0).negated_fields as *mut C2RustUnnamed_5 as *mut Array,
        1 as libc::c_int as uint32_t,
        ::core::mem::size_of::<TSFieldId>() as libc::c_ulong,
    );
    let fresh15 = (*self_0).negated_fields.size;
    (*self_0).negated_fields.size = ((*self_0).negated_fields.size).wrapping_add(1);
    *((*self_0).negated_fields.contents).offset(fresh15 as isize) = 0 as libc::c_int as TSFieldId;
}
unsafe extern "C" fn ts_query__parse_string_literal(
    mut self_0: *mut TSQuery,
    mut stream: *mut Stream,
) -> TSQueryError {
    let mut string_start: *const libc::c_char = (*stream).input;
    if (*stream).next != '"' as i32 {
        return TSQueryErrorSyntax;
    }
    stream_advance(stream);
    let mut prev_position: *const libc::c_char = (*stream).input;
    let mut is_escaped: bool = 0 as libc::c_int != 0;
    (*self_0).string_buffer.size = 0 as libc::c_int as uint32_t;
    loop {
        if is_escaped {
            is_escaped = 0 as libc::c_int != 0;
            match (*stream).next {
                110 => {
                    _array__grow(
                        &mut (*self_0).string_buffer as *mut C2RustUnnamed_4 as *mut Array,
                        1 as libc::c_int as uint32_t,
                        ::core::mem::size_of::<libc::c_char>() as libc::c_ulong,
                    );
                    let fresh16 = (*self_0).string_buffer.size;
                    (*self_0).string_buffer.size = ((*self_0).string_buffer.size).wrapping_add(1);
                    *((*self_0).string_buffer.contents).offset(fresh16 as isize) =
                        '\n' as i32 as libc::c_char;
                }
                114 => {
                    _array__grow(
                        &mut (*self_0).string_buffer as *mut C2RustUnnamed_4 as *mut Array,
                        1 as libc::c_int as uint32_t,
                        ::core::mem::size_of::<libc::c_char>() as libc::c_ulong,
                    );
                    let fresh17 = (*self_0).string_buffer.size;
                    (*self_0).string_buffer.size = ((*self_0).string_buffer.size).wrapping_add(1);
                    *((*self_0).string_buffer.contents).offset(fresh17 as isize) =
                        '\r' as i32 as libc::c_char;
                }
                116 => {
                    _array__grow(
                        &mut (*self_0).string_buffer as *mut C2RustUnnamed_4 as *mut Array,
                        1 as libc::c_int as uint32_t,
                        ::core::mem::size_of::<libc::c_char>() as libc::c_ulong,
                    );
                    let fresh18 = (*self_0).string_buffer.size;
                    (*self_0).string_buffer.size = ((*self_0).string_buffer.size).wrapping_add(1);
                    *((*self_0).string_buffer.contents).offset(fresh18 as isize) =
                        '\t' as i32 as libc::c_char;
                }
                48 => {
                    _array__grow(
                        &mut (*self_0).string_buffer as *mut C2RustUnnamed_4 as *mut Array,
                        1 as libc::c_int as uint32_t,
                        ::core::mem::size_of::<libc::c_char>() as libc::c_ulong,
                    );
                    let fresh19 = (*self_0).string_buffer.size;
                    (*self_0).string_buffer.size = ((*self_0).string_buffer.size).wrapping_add(1);
                    *((*self_0).string_buffer.contents).offset(fresh19 as isize) =
                        '\0' as i32 as libc::c_char;
                }
                _ => {
                    _array__splice(
                        &mut (*self_0).string_buffer as *mut C2RustUnnamed_4 as *mut Array,
                        ::core::mem::size_of::<libc::c_char>() as libc::c_ulong,
                        (*self_0).string_buffer.size,
                        0 as libc::c_int as uint32_t,
                        (*stream).next_size as uint32_t,
                        (*stream).input as *const libc::c_void,
                    );
                }
            }
            prev_position = ((*stream).input).offset((*stream).next_size as libc::c_int as isize);
        } else if (*stream).next == '\\' as i32 {
            _array__splice(
                &mut (*self_0).string_buffer as *mut C2RustUnnamed_4 as *mut Array,
                ::core::mem::size_of::<libc::c_char>() as libc::c_ulong,
                (*self_0).string_buffer.size,
                0 as libc::c_int as uint32_t,
                ((*stream).input).offset_from(prev_position) as libc::c_long as uint32_t,
                prev_position as *const libc::c_void,
            );
            prev_position = ((*stream).input).offset(1 as libc::c_int as isize);
            is_escaped = 1 as libc::c_int != 0;
        } else if (*stream).next == '"' as i32 {
            _array__splice(
                &mut (*self_0).string_buffer as *mut C2RustUnnamed_4 as *mut Array,
                ::core::mem::size_of::<libc::c_char>() as libc::c_ulong,
                (*self_0).string_buffer.size,
                0 as libc::c_int as uint32_t,
                ((*stream).input).offset_from(prev_position) as libc::c_long as uint32_t,
                prev_position as *const libc::c_void,
            );
            stream_advance(stream);
            return TSQueryErrorNone;
        } else {
            if (*stream).next == '\n' as i32 {
                stream_reset(stream, string_start);
                return TSQueryErrorSyntax;
            }
        }
        if !stream_advance(stream) {
            stream_reset(stream, string_start);
            return TSQueryErrorSyntax;
        }
    }
}
unsafe extern "C" fn ts_query__parse_predicate(
    mut self_0: *mut TSQuery,
    mut stream: *mut Stream,
) -> TSQueryError {
    if !stream_is_ident_start(stream) {
        return TSQueryErrorSyntax;
    }
    let mut predicate_name: *const libc::c_char = (*stream).input;
    stream_scan_identifier(stream);
    let mut length: uint32_t =
        ((*stream).input).offset_from(predicate_name) as libc::c_long as uint32_t;
    let mut id: uint16_t =
        symbol_table_insert_name(&mut (*self_0).predicate_values, predicate_name, length);
    _array__grow(
        &mut (*self_0).predicate_steps as *mut C2RustUnnamed_8 as *mut Array,
        1 as libc::c_int as uint32_t,
        ::core::mem::size_of::<TSQueryPredicateStep>() as libc::c_ulong,
    );
    let fresh20 = (*self_0).predicate_steps.size;
    (*self_0).predicate_steps.size = ((*self_0).predicate_steps.size).wrapping_add(1);
    *((*self_0).predicate_steps.contents).offset(fresh20 as isize) = {
        let mut init = TSQueryPredicateStep {
            type_: TSQueryPredicateStepTypeString,
            value_id: id as uint32_t,
        };
        init
    };
    stream_skip_whitespace(stream);
    loop {
        if (*stream).next == ')' as i32 {
            stream_advance(stream);
            stream_skip_whitespace(stream);
            _array__grow(
                &mut (*self_0).predicate_steps as *mut C2RustUnnamed_8 as *mut Array,
                1 as libc::c_int as uint32_t,
                ::core::mem::size_of::<TSQueryPredicateStep>() as libc::c_ulong,
            );
            let fresh21 = (*self_0).predicate_steps.size;
            (*self_0).predicate_steps.size = ((*self_0).predicate_steps.size).wrapping_add(1);
            *((*self_0).predicate_steps.contents).offset(fresh21 as isize) = {
                let mut init = TSQueryPredicateStep {
                    type_: TSQueryPredicateStepTypeDone,
                    value_id: 0 as libc::c_int as uint32_t,
                };
                init
            };
            break;
        } else {
            if (*stream).next == '@' as i32 {
                stream_advance(stream);
                if !stream_is_ident_start(stream) {
                    return TSQueryErrorSyntax;
                }
                let mut capture_name: *const libc::c_char = (*stream).input;
                stream_scan_identifier(stream);
                let mut capture_length: uint32_t =
                    ((*stream).input).offset_from(capture_name) as libc::c_long as uint32_t;
                let mut capture_id: libc::c_int =
                    symbol_table_id_for_name(&mut (*self_0).captures, capture_name, capture_length);
                if capture_id == -(1 as libc::c_int) {
                    stream_reset(stream, capture_name);
                    return TSQueryErrorCapture;
                }
                _array__grow(
                    &mut (*self_0).predicate_steps as *mut C2RustUnnamed_8 as *mut Array,
                    1 as libc::c_int as uint32_t,
                    ::core::mem::size_of::<TSQueryPredicateStep>() as libc::c_ulong,
                );
                let fresh22 = (*self_0).predicate_steps.size;
                (*self_0).predicate_steps.size = ((*self_0).predicate_steps.size).wrapping_add(1);
                *((*self_0).predicate_steps.contents).offset(fresh22 as isize) = {
                    let mut init = TSQueryPredicateStep {
                        type_: TSQueryPredicateStepTypeCapture,
                        value_id: capture_id as uint32_t,
                    };
                    init
                };
            } else if (*stream).next == '"' as i32 {
                let mut e: TSQueryError = ts_query__parse_string_literal(self_0, stream);
                if e as u64 != 0 {
                    return e;
                }
                let mut query_id: uint16_t = symbol_table_insert_name(
                    &mut (*self_0).predicate_values,
                    (*self_0).string_buffer.contents,
                    (*self_0).string_buffer.size,
                );
                _array__grow(
                    &mut (*self_0).predicate_steps as *mut C2RustUnnamed_8 as *mut Array,
                    1 as libc::c_int as uint32_t,
                    ::core::mem::size_of::<TSQueryPredicateStep>() as libc::c_ulong,
                );
                let fresh23 = (*self_0).predicate_steps.size;
                (*self_0).predicate_steps.size = ((*self_0).predicate_steps.size).wrapping_add(1);
                *((*self_0).predicate_steps.contents).offset(fresh23 as isize) = {
                    let mut init = TSQueryPredicateStep {
                        type_: TSQueryPredicateStepTypeString,
                        value_id: query_id as uint32_t,
                    };
                    init
                };
            } else if stream_is_ident_start(stream) {
                let mut symbol_start: *const libc::c_char = (*stream).input;
                stream_scan_identifier(stream);
                let mut symbol_length: uint32_t =
                    ((*stream).input).offset_from(symbol_start) as libc::c_long as uint32_t;
                let mut query_id_0: uint16_t = symbol_table_insert_name(
                    &mut (*self_0).predicate_values,
                    symbol_start,
                    symbol_length,
                );
                _array__grow(
                    &mut (*self_0).predicate_steps as *mut C2RustUnnamed_8 as *mut Array,
                    1 as libc::c_int as uint32_t,
                    ::core::mem::size_of::<TSQueryPredicateStep>() as libc::c_ulong,
                );
                let fresh24 = (*self_0).predicate_steps.size;
                (*self_0).predicate_steps.size = ((*self_0).predicate_steps.size).wrapping_add(1);
                *((*self_0).predicate_steps.contents).offset(fresh24 as isize) = {
                    let mut init = TSQueryPredicateStep {
                        type_: TSQueryPredicateStepTypeString,
                        value_id: query_id_0 as uint32_t,
                    };
                    init
                };
            } else {
                return TSQueryErrorSyntax;
            }
            stream_skip_whitespace(stream);
        }
    }
    return TSQueryErrorNone;
}
unsafe extern "C" fn ts_query__parse_pattern(
    mut self_0: *mut TSQuery,
    mut stream: *mut Stream,
    mut depth: uint32_t,
    mut is_immediate: bool,
    mut capture_quantifiers: *mut CaptureQuantifiers,
) -> TSQueryError {
    if (*stream).next == 0 as libc::c_int {
        return TSQueryErrorSyntax;
    }
    if (*stream).next == ')' as i32 || (*stream).next == ']' as i32 {
        return PARENT_DONE;
    }
    let starting_step_index: uint32_t = (*self_0).steps.size;
    if (*self_0).step_offsets.size == 0 as libc::c_int as libc::c_uint || {
        if ((*self_0).step_offsets.size).wrapping_sub(1 as libc::c_int as libc::c_uint)
            < (*self_0).step_offsets.size
        {
        } else {
            panic!();
        }
        (*(&mut *((*self_0).step_offsets.contents).offset(
            ((*self_0).step_offsets.size).wrapping_sub(1 as libc::c_int as libc::c_uint) as isize,
        ) as *mut StepOffset))
            .step_index as libc::c_uint
            != starting_step_index
    } {
        _array__grow(
            &mut (*self_0).step_offsets as *mut C2RustUnnamed_6 as *mut Array,
            1 as libc::c_int as uint32_t,
            ::core::mem::size_of::<StepOffset>() as libc::c_ulong,
        );
        let fresh25 = (*self_0).step_offsets.size;
        (*self_0).step_offsets.size = ((*self_0).step_offsets.size).wrapping_add(1);
        *((*self_0).step_offsets.contents).offset(fresh25 as isize) = {
            let mut init = StepOffset {
                byte_offset: stream_offset(stream),
                step_index: starting_step_index as uint16_t,
            };
            init
        };
    }
    if (*stream).next == '[' as i32 {
        stream_advance(stream);
        stream_skip_whitespace(stream);
        let mut branch_step_indices: C2RustUnnamed_25 = {
            let mut init = C2RustUnnamed_25 {
                contents: 0 as *mut uint32_t,
                size: 0 as libc::c_int as uint32_t,
                capacity: 0 as libc::c_int as uint32_t,
            };
            init
        };
        let mut branch_capture_quantifiers: CaptureQuantifiers = capture_quantifiers_new();
        loop {
            let mut start_index: uint32_t = (*self_0).steps.size;
            let mut e: TSQueryError = ts_query__parse_pattern(
                self_0,
                stream,
                depth,
                is_immediate,
                &mut branch_capture_quantifiers,
            );
            if e as libc::c_uint == PARENT_DONE as libc::c_uint {
                if (*stream).next == ']' as i32
                    && branch_step_indices.size > 0 as libc::c_int as libc::c_uint
                {
                    stream_advance(stream);
                    break;
                } else {
                    e = TSQueryErrorSyntax;
                }
            }
            if e as u64 != 0 {
                capture_quantifiers_delete(&mut branch_capture_quantifiers);
                _array__delete(&mut branch_step_indices as *mut C2RustUnnamed_25 as *mut Array);
                return e;
            }
            if start_index == starting_step_index {
                capture_quantifiers_replace(capture_quantifiers, &mut branch_capture_quantifiers);
            } else {
                capture_quantifiers_join_all(capture_quantifiers, &mut branch_capture_quantifiers);
            }
            _array__grow(
                &mut branch_step_indices as *mut C2RustUnnamed_25 as *mut Array,
                1 as libc::c_int as uint32_t,
                ::core::mem::size_of::<uint32_t>() as libc::c_ulong,
            );
            let fresh26 = branch_step_indices.size;
            branch_step_indices.size = (branch_step_indices.size).wrapping_add(1);
            *(branch_step_indices.contents).offset(fresh26 as isize) = start_index;
            _array__grow(
                &mut (*self_0).steps as *mut C2RustUnnamed_10 as *mut Array,
                1 as libc::c_int as uint32_t,
                ::core::mem::size_of::<QueryStep>() as libc::c_ulong,
            );
            let fresh27 = (*self_0).steps.size;
            (*self_0).steps.size = ((*self_0).steps.size).wrapping_add(1);
            *((*self_0).steps.contents).offset(fresh27 as isize) = query_step__new(
                0 as libc::c_int as TSSymbol,
                depth as uint16_t,
                0 as libc::c_int != 0,
            );
            capture_quantifiers_clear(&mut branch_capture_quantifiers);
        }
        (*self_0).steps.size = ((*self_0).steps.size).wrapping_sub(1);
        let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
        while i < (branch_step_indices.size).wrapping_sub(1 as libc::c_int as libc::c_uint) {
            let mut step_index: uint32_t = *(branch_step_indices.contents).offset(i as isize);
            let mut next_step_index: uint32_t = *(branch_step_indices.contents)
                .offset(i.wrapping_add(1 as libc::c_int as libc::c_uint) as isize);
            let mut start_step: *mut QueryStep =
                &mut *((*self_0).steps.contents).offset(step_index as isize) as *mut QueryStep;
            let mut end_step: *mut QueryStep = &mut *((*self_0).steps.contents)
                .offset(next_step_index.wrapping_sub(1 as libc::c_int as libc::c_uint) as isize)
                as *mut QueryStep;
            (*start_step).alternative_index = next_step_index as uint16_t;
            (*end_step).alternative_index = (*self_0).steps.size as uint16_t;
            (*end_step).set_is_dead_end(1 as libc::c_int != 0);
            i = i.wrapping_add(1);
        }
        capture_quantifiers_delete(&mut branch_capture_quantifiers);
        _array__delete(&mut branch_step_indices as *mut C2RustUnnamed_25 as *mut Array);
    } else if (*stream).next == '(' as i32 {
        stream_advance(stream);
        stream_skip_whitespace(stream);
        if (*stream).next == '(' as i32
            || (*stream).next == '"' as i32
            || (*stream).next == '[' as i32
        {
            let mut child_is_immediate: bool = is_immediate;
            let mut child_capture_quantifiers: CaptureQuantifiers = capture_quantifiers_new();
            loop {
                if (*stream).next == '.' as i32 {
                    child_is_immediate = 1 as libc::c_int != 0;
                    stream_advance(stream);
                    stream_skip_whitespace(stream);
                }
                let mut e_0: TSQueryError = ts_query__parse_pattern(
                    self_0,
                    stream,
                    depth,
                    child_is_immediate,
                    &mut child_capture_quantifiers,
                );
                if e_0 as libc::c_uint == PARENT_DONE as libc::c_uint {
                    if (*stream).next == ')' as i32 {
                        stream_advance(stream);
                        break;
                    } else {
                        e_0 = TSQueryErrorSyntax;
                    }
                }
                if e_0 as u64 != 0 {
                    capture_quantifiers_delete(&mut child_capture_quantifiers);
                    return e_0;
                }
                capture_quantifiers_add_all(capture_quantifiers, &mut child_capture_quantifiers);
                capture_quantifiers_clear(&mut child_capture_quantifiers);
                child_is_immediate = 0 as libc::c_int != 0;
            }
            capture_quantifiers_delete(&mut child_capture_quantifiers);
        } else if (*stream).next == '.' as i32 || (*stream).next == '#' as i32 {
            stream_advance(stream);
            return ts_query__parse_predicate(self_0, stream);
        } else {
            let mut symbol: TSSymbol = 0;
            if stream_is_ident_start(stream) {
                let mut node_name: *const libc::c_char = (*stream).input;
                stream_scan_identifier(stream);
                let mut length: uint32_t =
                    ((*stream).input).offset_from(node_name) as libc::c_long as uint32_t;
                if length == 1 as libc::c_int as libc::c_uint
                    && *node_name.offset(0 as libc::c_int as isize) as libc::c_int == '_' as i32
                {
                    symbol = WILDCARD_SYMBOL;
                } else {
                    symbol = ts_language_symbol_for_name(
                        (*self_0).language,
                        node_name,
                        length,
                        1 as libc::c_int != 0,
                    );
                    if symbol == 0 {
                        stream_reset(stream, node_name);
                        return TSQueryErrorNodeType;
                    }
                }
            } else {
                return TSQueryErrorSyntax;
            }
            _array__grow(
                &mut (*self_0).steps as *mut C2RustUnnamed_10 as *mut Array,
                1 as libc::c_int as uint32_t,
                ::core::mem::size_of::<QueryStep>() as libc::c_ulong,
            );
            let fresh28 = (*self_0).steps.size;
            (*self_0).steps.size = ((*self_0).steps.size).wrapping_add(1);
            *((*self_0).steps.contents).offset(fresh28 as isize) =
                query_step__new(symbol, depth as uint16_t, is_immediate);
            if ((*self_0).steps.size).wrapping_sub(1 as libc::c_int as libc::c_uint)
                < (*self_0).steps.size
            {
            } else {
                panic!();
            }
            let mut step: *mut QueryStep = &mut *((*self_0).steps.contents).offset(
                ((*self_0).steps.size).wrapping_sub(1 as libc::c_int as libc::c_uint) as isize,
            ) as *mut QueryStep;
            if (ts_language_symbol_metadata((*self_0).language, symbol)).supertype {
                (*step).supertype_symbol = (*step).symbol;
                (*step).symbol = WILDCARD_SYMBOL;
            }
            if symbol as libc::c_int == WILDCARD_SYMBOL as libc::c_int {
                (*step).set_is_named(1 as libc::c_int != 0);
            }
            stream_skip_whitespace(stream);
            if (*stream).next == '/' as i32 {
                stream_advance(stream);
                if !stream_is_ident_start(stream) {
                    return TSQueryErrorSyntax;
                }
                let mut node_name_0: *const libc::c_char = (*stream).input;
                stream_scan_identifier(stream);
                let mut length_0: uint32_t =
                    ((*stream).input).offset_from(node_name_0) as libc::c_long as uint32_t;
                (*step).symbol = ts_language_symbol_for_name(
                    (*self_0).language,
                    node_name_0,
                    length_0,
                    1 as libc::c_int != 0,
                );
                if (*step).symbol == 0 {
                    stream_reset(stream, node_name_0);
                    return TSQueryErrorNodeType;
                }
                stream_skip_whitespace(stream);
            }
            let mut child_is_immediate_0: bool = 0 as libc::c_int != 0;
            let mut last_child_step_index: uint16_t = 0 as libc::c_int as uint16_t;
            let mut negated_field_count: uint16_t = 0 as libc::c_int as uint16_t;
            let mut negated_field_ids: [TSFieldId; 8] = [0; 8];
            let mut child_capture_quantifiers_0: CaptureQuantifiers = capture_quantifiers_new();
            loop {
                if (*stream).next == '!' as i32 {
                    stream_advance(stream);
                    stream_skip_whitespace(stream);
                    if !stream_is_ident_start(stream) {
                        capture_quantifiers_delete(&mut child_capture_quantifiers_0);
                        return TSQueryErrorSyntax;
                    }
                    let mut field_name: *const libc::c_char = (*stream).input;
                    stream_scan_identifier(stream);
                    let mut length_1: uint32_t =
                        ((*stream).input).offset_from(field_name) as libc::c_long as uint32_t;
                    stream_skip_whitespace(stream);
                    let mut field_id: TSFieldId =
                        ts_language_field_id_for_name((*self_0).language, field_name, length_1);
                    if field_id == 0 {
                        (*stream).input = field_name;
                        capture_quantifiers_delete(&mut child_capture_quantifiers_0);
                        return TSQueryErrorField;
                    }
                    if (negated_field_count as libc::c_int) < 8 as libc::c_int {
                        negated_field_ids[negated_field_count as usize] = field_id;
                        negated_field_count = negated_field_count.wrapping_add(1);
                    }
                } else {
                    if (*stream).next == '.' as i32 {
                        child_is_immediate_0 = 1 as libc::c_int != 0;
                        stream_advance(stream);
                        stream_skip_whitespace(stream);
                    }
                    let mut step_index_0: uint16_t = (*self_0).steps.size as uint16_t;
                    let mut e_1: TSQueryError = ts_query__parse_pattern(
                        self_0,
                        stream,
                        depth.wrapping_add(1 as libc::c_int as libc::c_uint),
                        child_is_immediate_0,
                        &mut child_capture_quantifiers_0,
                    );
                    if e_1 as libc::c_uint == PARENT_DONE as libc::c_uint {
                        if (*stream).next == ')' as i32 {
                            if child_is_immediate_0 {
                                if last_child_step_index as libc::c_int == 0 as libc::c_int {
                                    capture_quantifiers_delete(&mut child_capture_quantifiers_0);
                                    return TSQueryErrorSyntax;
                                }
                                let ref mut fresh29 = *((*self_0).steps.contents)
                                    .offset(last_child_step_index as isize);
                                (*fresh29).set_is_last_child(1 as libc::c_int != 0);
                            }
                            if negated_field_count != 0 {
                                ts_query__add_negated_fields(
                                    self_0,
                                    starting_step_index as uint16_t,
                                    negated_field_ids.as_mut_ptr(),
                                    negated_field_count,
                                );
                            }
                            stream_advance(stream);
                            break;
                        } else {
                            e_1 = TSQueryErrorSyntax;
                        }
                    }
                    if e_1 as u64 != 0 {
                        capture_quantifiers_delete(&mut child_capture_quantifiers_0);
                        return e_1;
                    }
                    capture_quantifiers_add_all(
                        capture_quantifiers,
                        &mut child_capture_quantifiers_0,
                    );
                    last_child_step_index = step_index_0;
                    child_is_immediate_0 = 0 as libc::c_int != 0;
                    capture_quantifiers_clear(&mut child_capture_quantifiers_0);
                }
            }
            capture_quantifiers_delete(&mut child_capture_quantifiers_0);
        }
    } else if (*stream).next == '_' as i32 {
        stream_advance(stream);
        stream_skip_whitespace(stream);
        _array__grow(
            &mut (*self_0).steps as *mut C2RustUnnamed_10 as *mut Array,
            1 as libc::c_int as uint32_t,
            ::core::mem::size_of::<QueryStep>() as libc::c_ulong,
        );
        let fresh30 = (*self_0).steps.size;
        (*self_0).steps.size = ((*self_0).steps.size).wrapping_add(1);
        *((*self_0).steps.contents).offset(fresh30 as isize) =
            query_step__new(WILDCARD_SYMBOL, depth as uint16_t, is_immediate);
    } else if (*stream).next == '"' as i32 {
        let mut string_start: *const libc::c_char = (*stream).input;
        let mut e_2: TSQueryError = ts_query__parse_string_literal(self_0, stream);
        if e_2 as u64 != 0 {
            return e_2;
        }
        let mut symbol_0: TSSymbol = ts_language_symbol_for_name(
            (*self_0).language,
            (*self_0).string_buffer.contents,
            (*self_0).string_buffer.size,
            0 as libc::c_int != 0,
        );
        if symbol_0 == 0 {
            stream_reset(stream, string_start.offset(1 as libc::c_int as isize));
            return TSQueryErrorNodeType;
        }
        _array__grow(
            &mut (*self_0).steps as *mut C2RustUnnamed_10 as *mut Array,
            1 as libc::c_int as uint32_t,
            ::core::mem::size_of::<QueryStep>() as libc::c_ulong,
        );
        let fresh31 = (*self_0).steps.size;
        (*self_0).steps.size = ((*self_0).steps.size).wrapping_add(1);
        *((*self_0).steps.contents).offset(fresh31 as isize) =
            query_step__new(symbol_0, depth as uint16_t, is_immediate);
    } else if stream_is_ident_start(stream) {
        let mut field_name_0: *const libc::c_char = (*stream).input;
        stream_scan_identifier(stream);
        let mut length_2: uint32_t =
            ((*stream).input).offset_from(field_name_0) as libc::c_long as uint32_t;
        stream_skip_whitespace(stream);
        if (*stream).next != ':' as i32 {
            stream_reset(stream, field_name_0);
            return TSQueryErrorSyntax;
        }
        stream_advance(stream);
        stream_skip_whitespace(stream);
        let mut field_capture_quantifiers: CaptureQuantifiers = capture_quantifiers_new();
        let mut e_3: TSQueryError = ts_query__parse_pattern(
            self_0,
            stream,
            depth,
            is_immediate,
            &mut field_capture_quantifiers,
        );
        if e_3 as u64 != 0 {
            capture_quantifiers_delete(&mut field_capture_quantifiers);
            if e_3 as libc::c_uint == PARENT_DONE as libc::c_uint {
                e_3 = TSQueryErrorSyntax;
            }
            return e_3;
        }
        let mut field_id_0: TSFieldId =
            ts_language_field_id_for_name((*self_0).language, field_name_0, length_2);
        if field_id_0 == 0 {
            (*stream).input = field_name_0;
            return TSQueryErrorField;
        }
        let mut step_index_1: uint32_t = starting_step_index;
        let mut step_0: *mut QueryStep =
            &mut *((*self_0).steps.contents).offset(step_index_1 as isize) as *mut QueryStep;
        loop {
            (*step_0).field = field_id_0;
            if !((*step_0).alternative_index as libc::c_int != NONE as libc::c_int
                && (*step_0).alternative_index as libc::c_uint > step_index_1
                && ((*step_0).alternative_index as libc::c_uint) < (*self_0).steps.size)
            {
                break;
            }
            step_index_1 = (*step_0).alternative_index as uint32_t;
            step_0 =
                &mut *((*self_0).steps.contents).offset(step_index_1 as isize) as *mut QueryStep;
        }
        capture_quantifiers_add_all(capture_quantifiers, &mut field_capture_quantifiers);
        capture_quantifiers_delete(&mut field_capture_quantifiers);
    } else {
        return TSQueryErrorSyntax;
    }
    stream_skip_whitespace(stream);
    let mut quantifier: TSQuantifier = TSQuantifierOne;
    loop {
        if (*stream).next == '+' as i32 {
            quantifier = quantifier_join(TSQuantifierOneOrMore, quantifier);
            stream_advance(stream);
            stream_skip_whitespace(stream);
            let mut repeat_step: QueryStep =
                query_step__new(WILDCARD_SYMBOL, depth as uint16_t, 0 as libc::c_int != 0);
            repeat_step.alternative_index = starting_step_index as uint16_t;
            repeat_step.set_is_pass_through(1 as libc::c_int != 0);
            repeat_step.set_alternative_is_immediate(1 as libc::c_int != 0);
            _array__grow(
                &mut (*self_0).steps as *mut C2RustUnnamed_10 as *mut Array,
                1 as libc::c_int as uint32_t,
                ::core::mem::size_of::<QueryStep>() as libc::c_ulong,
            );
            let fresh32 = (*self_0).steps.size;
            (*self_0).steps.size = ((*self_0).steps.size).wrapping_add(1);
            *((*self_0).steps.contents).offset(fresh32 as isize) = repeat_step;
        } else if (*stream).next == '*' as i32 {
            quantifier = quantifier_join(TSQuantifierZeroOrMore, quantifier);
            stream_advance(stream);
            stream_skip_whitespace(stream);
            let mut repeat_step_0: QueryStep =
                query_step__new(WILDCARD_SYMBOL, depth as uint16_t, 0 as libc::c_int != 0);
            repeat_step_0.alternative_index = starting_step_index as uint16_t;
            repeat_step_0.set_is_pass_through(1 as libc::c_int != 0);
            repeat_step_0.set_alternative_is_immediate(1 as libc::c_int != 0);
            _array__grow(
                &mut (*self_0).steps as *mut C2RustUnnamed_10 as *mut Array,
                1 as libc::c_int as uint32_t,
                ::core::mem::size_of::<QueryStep>() as libc::c_ulong,
            );
            let fresh33 = (*self_0).steps.size;
            (*self_0).steps.size = ((*self_0).steps.size).wrapping_add(1);
            *((*self_0).steps.contents).offset(fresh33 as isize) = repeat_step_0;
            let mut step_1: *mut QueryStep = &mut *((*self_0).steps.contents)
                .offset(starting_step_index as isize)
                as *mut QueryStep;
            while (*step_1).alternative_index as libc::c_int != NONE as libc::c_int
                && ((*step_1).alternative_index as libc::c_uint)
                    < ((*self_0).steps.size).wrapping_sub(1 as libc::c_int as libc::c_uint)
            {
                step_1 = &mut *((*self_0).steps.contents)
                    .offset((*step_1).alternative_index as isize)
                    as *mut QueryStep;
            }
            (*step_1).alternative_index = (*self_0).steps.size as uint16_t;
        } else if (*stream).next == '?' as i32 {
            quantifier = quantifier_join(TSQuantifierZeroOrOne, quantifier);
            stream_advance(stream);
            stream_skip_whitespace(stream);
            let mut step_2: *mut QueryStep = &mut *((*self_0).steps.contents)
                .offset(starting_step_index as isize)
                as *mut QueryStep;
            while (*step_2).alternative_index as libc::c_int != NONE as libc::c_int
                && ((*step_2).alternative_index as libc::c_uint) < (*self_0).steps.size
            {
                step_2 = &mut *((*self_0).steps.contents)
                    .offset((*step_2).alternative_index as isize)
                    as *mut QueryStep;
            }
            (*step_2).alternative_index = (*self_0).steps.size as uint16_t;
        } else {
            if !((*stream).next == '@' as i32) {
                break;
            }
            stream_advance(stream);
            if !stream_is_ident_start(stream) {
                return TSQueryErrorSyntax;
            }
            let mut capture_name: *const libc::c_char = (*stream).input;
            stream_scan_identifier(stream);
            let mut length_3: uint32_t =
                ((*stream).input).offset_from(capture_name) as libc::c_long as uint32_t;
            stream_skip_whitespace(stream);
            let mut capture_id: uint16_t =
                symbol_table_insert_name(&mut (*self_0).captures, capture_name, length_3);
            capture_quantifiers_add_for_id(capture_quantifiers, capture_id, TSQuantifierOne);
            let mut step_index_2: uint32_t = starting_step_index;
            loop {
                let mut step_3: *mut QueryStep = &mut *((*self_0).steps.contents)
                    .offset(step_index_2 as isize)
                    as *mut QueryStep;
                query_step__add_capture(step_3, capture_id);
                if !((*step_3).alternative_index as libc::c_int != NONE as libc::c_int
                    && (*step_3).alternative_index as libc::c_uint > step_index_2
                    && ((*step_3).alternative_index as libc::c_uint) < (*self_0).steps.size)
                {
                    break;
                }
                step_index_2 = (*step_3).alternative_index as uint32_t;
            }
        }
    }
    capture_quantifiers_mul(capture_quantifiers, quantifier);
    return TSQueryErrorNone;
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_new(
    mut language: *const TSLanguage,
    mut source: *const libc::c_char,
    mut source_len: uint32_t,
    mut error_offset: *mut uint32_t,
    mut error_type: *mut TSQueryError,
) -> *mut TSQuery {
    if language.is_null()
        || (*language).version > 14 as libc::c_int as libc::c_uint
        || (*language).version < 13 as libc::c_int as libc::c_uint
    {
        *error_type = TSQueryErrorLanguage;
        return 0 as *mut TSQuery;
    }
    let mut self_0: *mut TSQuery = crate::core_transpiled::alloc::ts_malloc(::core::mem::size_of::<
        TSQuery,
    >()
        as libc::c_ulong) as *mut TSQuery;
    *self_0 = {
        let mut init = TSQuery {
            captures: symbol_table_new(),
            predicate_values: symbol_table_new(),
            capture_quantifiers: {
                let mut init = C2RustUnnamed_11 {
                    contents: 0 as *mut CaptureQuantifiers,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
            steps: {
                let mut init = C2RustUnnamed_10 {
                    contents: 0 as *mut QueryStep,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
            pattern_map: {
                let mut init = C2RustUnnamed_9 {
                    contents: 0 as *mut PatternEntry,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
            predicate_steps: {
                let mut init = C2RustUnnamed_8 {
                    contents: 0 as *mut TSQueryPredicateStep,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
            patterns: {
                let mut init = C2RustUnnamed_7 {
                    contents: 0 as *mut QueryPattern,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
            step_offsets: {
                let mut init = C2RustUnnamed_6 {
                    contents: 0 as *mut StepOffset,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
            negated_fields: {
                let mut init = C2RustUnnamed_5 {
                    contents: 0 as *mut TSFieldId,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
            string_buffer: {
                let mut init = C2RustUnnamed_4 {
                    contents: 0 as *mut libc::c_char,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
            repeat_symbols_with_rootless_patterns: {
                let mut init = C2RustUnnamed_3 {
                    contents: 0 as *mut TSSymbol,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
            language: ts_language_copy(language),
            wildcard_root_pattern_count: 0 as libc::c_int as uint16_t,
        };
        init
    };
    _array__grow(
        &mut (*self_0).negated_fields as *mut C2RustUnnamed_5 as *mut Array,
        1 as libc::c_int as uint32_t,
        ::core::mem::size_of::<TSFieldId>() as libc::c_ulong,
    );
    let fresh34 = (*self_0).negated_fields.size;
    (*self_0).negated_fields.size = ((*self_0).negated_fields.size).wrapping_add(1);
    *((*self_0).negated_fields.contents).offset(fresh34 as isize) = 0 as libc::c_int as TSFieldId;
    let mut stream: Stream = stream_new(source, source_len);
    stream_skip_whitespace(&mut stream);
    while stream.input < stream.end {
        let mut pattern_index: uint32_t = (*self_0).patterns.size;
        let mut start_step_index: uint32_t = (*self_0).steps.size;
        let mut start_predicate_step_index: uint32_t = (*self_0).predicate_steps.size;
        _array__grow(
            &mut (*self_0).patterns as *mut C2RustUnnamed_7 as *mut Array,
            1 as libc::c_int as uint32_t,
            ::core::mem::size_of::<QueryPattern>() as libc::c_ulong,
        );
        let fresh35 = (*self_0).patterns.size;
        (*self_0).patterns.size = ((*self_0).patterns.size).wrapping_add(1);
        *((*self_0).patterns.contents).offset(fresh35 as isize) = {
            let mut init = QueryPattern {
                steps: {
                    let mut init = Slice {
                        offset: start_step_index,
                        length: 0,
                    };
                    init
                },
                predicate_steps: {
                    let mut init = Slice {
                        offset: start_predicate_step_index,
                        length: 0,
                    };
                    init
                },
                start_byte: stream_offset(&mut stream),
                end_byte: 0,
                is_non_local: 0 as libc::c_int != 0,
            };
            init
        };
        let mut capture_quantifiers: CaptureQuantifiers = capture_quantifiers_new();
        *error_type = ts_query__parse_pattern(
            self_0,
            &mut stream,
            0 as libc::c_int as uint32_t,
            0 as libc::c_int != 0,
            &mut capture_quantifiers,
        );
        _array__grow(
            &mut (*self_0).steps as *mut C2RustUnnamed_10 as *mut Array,
            1 as libc::c_int as uint32_t,
            ::core::mem::size_of::<QueryStep>() as libc::c_ulong,
        );
        let fresh36 = (*self_0).steps.size;
        (*self_0).steps.size = ((*self_0).steps.size).wrapping_add(1);
        *((*self_0).steps.contents).offset(fresh36 as isize) = query_step__new(
            0 as libc::c_int as TSSymbol,
            PATTERN_DONE_MARKER,
            0 as libc::c_int != 0,
        );
        if ((*self_0).patterns.size).wrapping_sub(1 as libc::c_int as libc::c_uint)
            < (*self_0).patterns.size
        {
        } else {
            panic!();
        }
        let mut pattern: *mut QueryPattern = &mut *((*self_0).patterns.contents).offset(
            ((*self_0).patterns.size).wrapping_sub(1 as libc::c_int as libc::c_uint) as isize,
        ) as *mut QueryPattern;
        (*pattern).steps.length = ((*self_0).steps.size).wrapping_sub(start_step_index);
        (*pattern).predicate_steps.length =
            ((*self_0).predicate_steps.size).wrapping_sub(start_predicate_step_index);
        (*pattern).end_byte = stream_offset(&mut stream);
        if *error_type as u64 != 0 {
            if *error_type as libc::c_uint == PARENT_DONE as libc::c_uint {
                *error_type = TSQueryErrorSyntax;
            }
            *error_offset = stream_offset(&mut stream);
            capture_quantifiers_delete(&mut capture_quantifiers);
            ts_query_delete(self_0);
            return 0 as *mut TSQuery;
        }
        _array__grow(
            &mut (*self_0).capture_quantifiers as *mut C2RustUnnamed_11 as *mut Array,
            1 as libc::c_int as uint32_t,
            ::core::mem::size_of::<CaptureQuantifiers>() as libc::c_ulong,
        );
        let fresh37 = (*self_0).capture_quantifiers.size;
        (*self_0).capture_quantifiers.size = ((*self_0).capture_quantifiers.size).wrapping_add(1);
        *((*self_0).capture_quantifiers.contents).offset(fresh37 as isize) = capture_quantifiers;
        let mut wildcard_root_alternative_index: uint16_t = NONE;
        loop {
            let mut step: *mut QueryStep = &mut *((*self_0).steps.contents)
                .offset(start_step_index as isize)
                as *mut QueryStep;
            if (*step).symbol as libc::c_int == WILDCARD_SYMBOL as libc::c_int
                && (*step).depth as libc::c_int == 0 as libc::c_int
                && (*step).field == 0
            {
                let mut second_step: *mut QueryStep = &mut *((*self_0).steps.contents).offset(
                    start_step_index.wrapping_add(1 as libc::c_int as libc::c_uint) as isize,
                ) as *mut QueryStep;
                if (*second_step).symbol as libc::c_int != WILDCARD_SYMBOL as libc::c_int
                    && (*second_step).depth as libc::c_int == 1 as libc::c_int
                    && !(*second_step).is_immediate()
                {
                    wildcard_root_alternative_index = (*step).alternative_index;
                    start_step_index = (start_step_index as libc::c_uint)
                        .wrapping_add(1 as libc::c_int as libc::c_uint)
                        as uint32_t as uint32_t;
                    step = second_step;
                }
            }
            let mut start_depth: uint32_t = (*step).depth as uint32_t;
            let mut is_rooted: bool = start_depth == 0 as libc::c_int as libc::c_uint;
            let mut step_index: uint32_t =
                start_step_index.wrapping_add(1 as libc::c_int as libc::c_uint);
            while step_index < (*self_0).steps.size {
                let mut child_step: *mut QueryStep =
                    &mut *((*self_0).steps.contents).offset(step_index as isize) as *mut QueryStep;
                if (*child_step).is_dead_end() {
                    break;
                }
                if (*child_step).depth as libc::c_uint == start_depth {
                    is_rooted = 0 as libc::c_int != 0;
                    break;
                } else {
                    step_index = step_index.wrapping_add(1);
                }
            }
            ts_query__pattern_map_insert(self_0, (*step).symbol, {
                let mut init = PatternEntry {
                    step_index: start_step_index as uint16_t,
                    pattern_index: pattern_index as uint16_t,
                    is_rooted: is_rooted,
                };
                init
            });
            if (*step).symbol as libc::c_int == WILDCARD_SYMBOL as libc::c_int {
                (*self_0).wildcard_root_pattern_count =
                    ((*self_0).wildcard_root_pattern_count).wrapping_add(1);
            }
            if (*step).alternative_index as libc::c_int != NONE as libc::c_int {
                start_step_index = (*step).alternative_index as uint32_t;
            } else {
                if !(wildcard_root_alternative_index as libc::c_int != NONE as libc::c_int) {
                    break;
                }
                start_step_index = wildcard_root_alternative_index as uint32_t;
                wildcard_root_alternative_index = NONE;
            }
        }
    }
    if !ts_query__analyze_patterns(self_0, error_offset) {
        *error_type = TSQueryErrorStructure;
        ts_query_delete(self_0);
        return 0 as *mut TSQuery;
    }
    _array__delete(&mut (*self_0).string_buffer as *mut C2RustUnnamed_4 as *mut Array);
    return self_0;
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_delete(mut self_0: *mut TSQuery) {
    if !self_0.is_null() {
        _array__delete(&mut (*self_0).steps as *mut C2RustUnnamed_10 as *mut Array);
        _array__delete(&mut (*self_0).pattern_map as *mut C2RustUnnamed_9 as *mut Array);
        _array__delete(&mut (*self_0).predicate_steps as *mut C2RustUnnamed_8 as *mut Array);
        _array__delete(&mut (*self_0).patterns as *mut C2RustUnnamed_7 as *mut Array);
        _array__delete(&mut (*self_0).step_offsets as *mut C2RustUnnamed_6 as *mut Array);
        _array__delete(&mut (*self_0).string_buffer as *mut C2RustUnnamed_4 as *mut Array);
        _array__delete(&mut (*self_0).negated_fields as *mut C2RustUnnamed_5 as *mut Array);
        _array__delete(
            &mut (*self_0).repeat_symbols_with_rootless_patterns as *mut C2RustUnnamed_3
                as *mut Array,
        );
        ts_language_delete((*self_0).language);
        symbol_table_delete(&mut (*self_0).captures);
        symbol_table_delete(&mut (*self_0).predicate_values);
        let mut index: uint32_t = 0 as libc::c_int as uint32_t;
        while index < (*self_0).capture_quantifiers.size {
            if index < (*self_0).capture_quantifiers.size {
            } else {
                panic!();
            }
            let mut capture_quantifiers: *mut CaptureQuantifiers =
                &mut *((*self_0).capture_quantifiers.contents).offset(index as isize)
                    as *mut CaptureQuantifiers;
            capture_quantifiers_delete(capture_quantifiers);
            index = index.wrapping_add(1);
        }
        _array__delete(&mut (*self_0).capture_quantifiers as *mut C2RustUnnamed_11 as *mut Array);
        crate::core_transpiled::alloc::ts_free(self_0 as *mut libc::c_void);
    }
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_pattern_count(mut self_0: *const TSQuery) -> uint32_t {
    return (*self_0).patterns.size;
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_capture_count(mut self_0: *const TSQuery) -> uint32_t {
    return (*self_0).captures.slices.size;
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_string_count(mut self_0: *const TSQuery) -> uint32_t {
    return (*self_0).predicate_values.slices.size;
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_capture_name_for_id(
    mut self_0: *const TSQuery,
    mut index: uint32_t,
    mut length: *mut uint32_t,
) -> *const libc::c_char {
    return symbol_table_name_for_id(&(*self_0).captures, index as uint16_t, length);
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_capture_quantifier_for_id(
    mut self_0: *const TSQuery,
    mut pattern_index: uint32_t,
    mut capture_index: uint32_t,
) -> TSQuantifier {
    if pattern_index < (*self_0).capture_quantifiers.size {
    } else {
        panic!();
    }
    let mut capture_quantifiers: *mut CaptureQuantifiers =
        &mut *((*self_0).capture_quantifiers.contents).offset(pattern_index as isize)
            as *mut CaptureQuantifiers;
    return capture_quantifier_for_id(capture_quantifiers, capture_index as uint16_t);
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_string_value_for_id(
    mut self_0: *const TSQuery,
    mut index: uint32_t,
    mut length: *mut uint32_t,
) -> *const libc::c_char {
    return symbol_table_name_for_id(&(*self_0).predicate_values, index as uint16_t, length);
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_predicates_for_pattern(
    mut self_0: *const TSQuery,
    mut pattern_index: uint32_t,
    mut step_count: *mut uint32_t,
) -> *const TSQueryPredicateStep {
    let mut slice: Slice =
        (*((*self_0).patterns.contents).offset(pattern_index as isize)).predicate_steps;
    *step_count = slice.length;
    if ((*self_0).predicate_steps.contents).is_null() {
        return 0 as *const TSQueryPredicateStep;
    }
    return &mut *((*self_0).predicate_steps.contents).offset(slice.offset as isize)
        as *mut TSQueryPredicateStep;
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_start_byte_for_pattern(
    mut self_0: *const TSQuery,
    mut pattern_index: uint32_t,
) -> uint32_t {
    return (*((*self_0).patterns.contents).offset(pattern_index as isize)).start_byte;
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_end_byte_for_pattern(
    mut self_0: *const TSQuery,
    mut pattern_index: uint32_t,
) -> uint32_t {
    return (*((*self_0).patterns.contents).offset(pattern_index as isize)).end_byte;
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_is_pattern_rooted(
    mut self_0: *const TSQuery,
    mut pattern_index: uint32_t,
) -> bool {
    let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i < (*self_0).pattern_map.size {
        let mut entry: *mut PatternEntry =
            &mut *((*self_0).pattern_map.contents).offset(i as isize) as *mut PatternEntry;
        if (*entry).pattern_index as libc::c_uint == pattern_index {
            if !(*entry).is_rooted {
                return 0 as libc::c_int != 0;
            }
        }
        i = i.wrapping_add(1);
    }
    return 1 as libc::c_int != 0;
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_is_pattern_non_local(
    mut self_0: *const TSQuery,
    mut pattern_index: uint32_t,
) -> bool {
    if pattern_index < (*self_0).patterns.size {
        return (*((*self_0).patterns.contents).offset(pattern_index as isize)).is_non_local;
    } else {
        return 0 as libc::c_int != 0;
    };
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_is_pattern_guaranteed_at_step(
    mut self_0: *const TSQuery,
    mut byte_offset: uint32_t,
) -> bool {
    let mut step_index: uint32_t = 4294967295 as libc::c_uint;
    let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i < (*self_0).step_offsets.size {
        let mut step_offset: *mut StepOffset =
            &mut *((*self_0).step_offsets.contents).offset(i as isize) as *mut StepOffset;
        if (*step_offset).byte_offset > byte_offset {
            break;
        }
        step_index = (*step_offset).step_index as uint32_t;
        i = i.wrapping_add(1);
    }
    if step_index < (*self_0).steps.size {
        return (*((*self_0).steps.contents).offset(step_index as isize)).root_pattern_guaranteed();
    } else {
        return 0 as libc::c_int != 0;
    };
}
#[no_mangle]
pub unsafe extern "C" fn ts_query__step_is_fallible(
    mut self_0: *const TSQuery,
    mut step_index: uint16_t,
) -> bool {
    if (step_index as uint32_t).wrapping_add(1 as libc::c_int as libc::c_uint)
        < (*self_0).steps.size
    {
    } else {
        panic!();
    }
    let mut step: *mut QueryStep =
        &mut *((*self_0).steps.contents).offset(step_index as isize) as *mut QueryStep;
    let mut next_step: *mut QueryStep = &mut *((*self_0).steps.contents)
        .offset((step_index as libc::c_int + 1 as libc::c_int) as isize)
        as *mut QueryStep;
    return (*next_step).depth as libc::c_int != PATTERN_DONE_MARKER as libc::c_int
        && (*next_step).depth as libc::c_int > (*step).depth as libc::c_int
        && !(*next_step).parent_pattern_guaranteed();
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_disable_capture(
    mut self_0: *mut TSQuery,
    mut name: *const libc::c_char,
    mut length: uint32_t,
) {
    let mut id: libc::c_int = symbol_table_id_for_name(&mut (*self_0).captures, name, length);
    if id != -(1 as libc::c_int) {
        let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
        while i < (*self_0).steps.size {
            let mut step: *mut QueryStep =
                &mut *((*self_0).steps.contents).offset(i as isize) as *mut QueryStep;
            query_step__remove_capture(step, id as uint16_t);
            i = i.wrapping_add(1);
        }
    }
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_disable_pattern(
    mut self_0: *mut TSQuery,
    mut pattern_index: uint32_t,
) {
    let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i < (*self_0).pattern_map.size {
        let mut pattern: *mut PatternEntry =
            &mut *((*self_0).pattern_map.contents).offset(i as isize) as *mut PatternEntry;
        if (*pattern).pattern_index as libc::c_uint == pattern_index {
            _array__erase(
                &mut (*self_0).pattern_map as *mut C2RustUnnamed_9 as *mut Array,
                ::core::mem::size_of::<PatternEntry>() as libc::c_ulong,
                i,
            );
            i = i.wrapping_sub(1);
        }
        i = i.wrapping_add(1);
    }
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_cursor_new() -> *mut TSQueryCursor {
    let mut self_0: *mut TSQueryCursor = crate::core_transpiled::alloc::ts_malloc(
        ::core::mem::size_of::<TSQueryCursor>() as libc::c_ulong,
    ) as *mut TSQueryCursor;
    *self_0 = {
        let mut init = TSQueryCursor {
            query: 0 as *const TSQuery,
            cursor: TSTreeCursor {
                tree: 0 as *const libc::c_void,
                id: 0 as *const libc::c_void,
                context: [0; 3],
            },
            states: {
                let mut init = C2RustUnnamed_16 {
                    contents: 0 as *mut QueryState,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
            finished_states: {
                let mut init = C2RustUnnamed_15 {
                    contents: 0 as *mut QueryState,
                    size: 0 as libc::c_int as uint32_t,
                    capacity: 0 as libc::c_int as uint32_t,
                };
                init
            },
            capture_list_pool: capture_list_pool_new(),
            depth: 0,
            max_start_depth: 4294967295 as libc::c_uint,
            start_byte: 0 as libc::c_int as uint32_t,
            end_byte: 4294967295 as libc::c_uint,
            start_point: {
                let mut init = TSPoint {
                    row: 0 as libc::c_int as uint32_t,
                    column: 0 as libc::c_int as uint32_t,
                };
                init
            },
            end_point: {
                let mut init = TSPoint {
                    row: 4294967295 as libc::c_uint,
                    column: 4294967295 as libc::c_uint,
                };
                init
            },
            next_state_id: 0,
            end_clock: clock_null(),
            timeout_duration: 0 as libc::c_int as TSDuration,
            operation_count: 0 as libc::c_int as libc::c_uint,
            on_visible_node: false,
            ascending: 0 as libc::c_int != 0,
            halted: 0 as libc::c_int != 0,
            did_exceed_match_limit: 0 as libc::c_int != 0,
        };
        init
    };
    _array__reserve(
        &mut (*self_0).states as *mut C2RustUnnamed_16 as *mut Array,
        ::core::mem::size_of::<QueryState>() as libc::c_ulong,
        8 as libc::c_int as uint32_t,
    );
    _array__reserve(
        &mut (*self_0).finished_states as *mut C2RustUnnamed_15 as *mut Array,
        ::core::mem::size_of::<QueryState>() as libc::c_ulong,
        8 as libc::c_int as uint32_t,
    );
    return self_0;
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_cursor_delete(mut self_0: *mut TSQueryCursor) {
    _array__delete(&mut (*self_0).states as *mut C2RustUnnamed_16 as *mut Array);
    _array__delete(&mut (*self_0).finished_states as *mut C2RustUnnamed_15 as *mut Array);
    ts_tree_cursor_delete(&mut (*self_0).cursor);
    capture_list_pool_delete(&mut (*self_0).capture_list_pool);
    crate::core_transpiled::alloc::ts_free(self_0 as *mut libc::c_void);
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_cursor_did_exceed_match_limit(
    mut self_0: *const TSQueryCursor,
) -> bool {
    return (*self_0).did_exceed_match_limit;
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_cursor_match_limit(mut self_0: *const TSQueryCursor) -> uint32_t {
    return (*self_0).capture_list_pool.max_capture_list_count;
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_cursor_set_match_limit(
    mut self_0: *mut TSQueryCursor,
    mut limit: uint32_t,
) {
    (*self_0).capture_list_pool.max_capture_list_count = limit;
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_cursor_timeout_micros(
    mut self_0: *const TSQueryCursor,
) -> uint64_t {
    return duration_to_micros((*self_0).timeout_duration);
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_cursor_set_timeout_micros(
    mut self_0: *mut TSQueryCursor,
    mut timeout_micros: uint64_t,
) {
    (*self_0).timeout_duration = duration_from_micros(timeout_micros);
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_cursor_exec(
    mut self_0: *mut TSQueryCursor,
    mut query: *const TSQuery,
    mut node: TSNode,
) {
    if !query.is_null() {
        let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
        while i < (*query).steps.size {
            let mut step: *mut QueryStep =
                &mut *((*query).steps.contents).offset(i as isize) as *mut QueryStep;
            if !((*step).depth as libc::c_int == PATTERN_DONE_MARKER as libc::c_int) {
                if !(*step).is_dead_end() {
                    if !(*step).is_pass_through() {
                        (*step).symbol as libc::c_int != WILDCARD_SYMBOL as libc::c_int;
                    }
                }
            }
            (*step).field != 0;
            (*step).alternative_index as libc::c_int != NONE as libc::c_int;
            i = i.wrapping_add(1);
        }
    }
    (*self_0).states.size = 0 as libc::c_int as uint32_t;
    (*self_0).finished_states.size = 0 as libc::c_int as uint32_t;
    ts_tree_cursor_reset(&mut (*self_0).cursor, node);
    capture_list_pool_reset(&mut (*self_0).capture_list_pool);
    (*self_0).on_visible_node = 1 as libc::c_int != 0;
    (*self_0).next_state_id = 0 as libc::c_int as uint32_t;
    (*self_0).depth = 0 as libc::c_int as uint32_t;
    (*self_0).ascending = 0 as libc::c_int != 0;
    (*self_0).halted = 0 as libc::c_int != 0;
    (*self_0).query = query;
    (*self_0).did_exceed_match_limit = 0 as libc::c_int != 0;
    (*self_0).operation_count = 0 as libc::c_int as libc::c_uint;
    if (*self_0).timeout_duration != 0 {
        (*self_0).end_clock = clock_after(clock_now(), (*self_0).timeout_duration);
    } else {
        (*self_0).end_clock = clock_null();
    };
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_cursor_set_byte_range(
    mut self_0: *mut TSQueryCursor,
    mut start_byte: uint32_t,
    mut end_byte: uint32_t,
) {
    if end_byte == 0 as libc::c_int as libc::c_uint {
        end_byte = 4294967295 as libc::c_uint;
    }
    (*self_0).start_byte = start_byte;
    (*self_0).end_byte = end_byte;
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_cursor_set_point_range(
    mut self_0: *mut TSQueryCursor,
    mut start_point: TSPoint,
    mut end_point: TSPoint,
) {
    if end_point.row == 0 as libc::c_int as libc::c_uint
        && end_point.column == 0 as libc::c_int as libc::c_uint
    {
        end_point = {
            let mut init = TSPoint {
                row: 4294967295 as libc::c_uint,
                column: 4294967295 as libc::c_uint,
            };
            init
        };
    }
    (*self_0).start_point = start_point;
    (*self_0).end_point = end_point;
}
unsafe extern "C" fn ts_query_cursor__first_in_progress_capture(
    mut self_0: *mut TSQueryCursor,
    mut state_index: *mut uint32_t,
    mut byte_offset: *mut uint32_t,
    mut pattern_index: *mut uint32_t,
    mut root_pattern_guaranteed: *mut bool,
) -> bool {
    let mut result: bool = 0 as libc::c_int != 0;
    *state_index = 4294967295 as libc::c_uint;
    *byte_offset = 4294967295 as libc::c_uint;
    *pattern_index = 4294967295 as libc::c_uint;
    let mut current_block_10: u64;
    let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i < (*self_0).states.size {
        let mut state: *mut QueryState =
            &mut *((*self_0).states.contents).offset(i as isize) as *mut QueryState;
        if !(*state).dead() {
            let mut captures: *const CaptureList = capture_list_pool_get(
                &mut (*self_0).capture_list_pool,
                (*state).capture_list_id as uint16_t,
            );
            if !((*state).consumed_capture_count() as libc::c_uint >= (*captures).size) {
                let mut node: TSNode = (*((*captures).contents)
                    .offset((*state).consumed_capture_count() as isize))
                .node;
                if ts_node_end_byte(node) <= (*self_0).start_byte
                    || point_lte(ts_node_end_point(node), (*self_0).start_point) as libc::c_int != 0
                {
                    (*state).set_consumed_capture_count((*state).consumed_capture_count() + 1);
                    i = i.wrapping_sub(1);
                } else {
                    let mut node_start_byte: uint32_t = ts_node_start_byte(node);
                    if !result
                        || node_start_byte < *byte_offset
                        || node_start_byte == *byte_offset
                            && ((*state).pattern_index as libc::c_uint) < *pattern_index
                    {
                        let mut step: *mut QueryStep = &mut *((*(*self_0).query).steps.contents)
                            .offset((*state).step_index as isize)
                            as *mut QueryStep;
                        if !root_pattern_guaranteed.is_null() {
                            *root_pattern_guaranteed = (*step).root_pattern_guaranteed();
                            current_block_10 = 17860125682698302841;
                        } else if (*step).root_pattern_guaranteed() {
                            current_block_10 = 14155750587950065367;
                        } else {
                            current_block_10 = 17860125682698302841;
                        }
                        match current_block_10 {
                            14155750587950065367 => {}
                            _ => {
                                result = 1 as libc::c_int != 0;
                                *state_index = i;
                                *byte_offset = node_start_byte;
                                *pattern_index = (*state).pattern_index as uint32_t;
                            }
                        }
                    }
                }
            }
        }
        i = i.wrapping_add(1);
    }
    return result;
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_cursor__compare_nodes(
    mut left: TSNode,
    mut right: TSNode,
) -> libc::c_int {
    if left.id != right.id {
        let mut left_start: uint32_t = ts_node_start_byte(left);
        let mut right_start: uint32_t = ts_node_start_byte(right);
        if left_start < right_start {
            return -(1 as libc::c_int);
        }
        if left_start > right_start {
            return 1 as libc::c_int;
        }
        let mut left_node_count: uint32_t = ts_node_end_byte(left);
        let mut right_node_count: uint32_t = ts_node_end_byte(right);
        if left_node_count > right_node_count {
            return -(1 as libc::c_int);
        }
        if left_node_count < right_node_count {
            return 1 as libc::c_int;
        }
    }
    return 0 as libc::c_int;
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_cursor__compare_captures(
    mut self_0: *mut TSQueryCursor,
    mut left_state: *mut QueryState,
    mut right_state: *mut QueryState,
    mut left_contains_right: *mut bool,
    mut right_contains_left: *mut bool,
) {
    let mut left_captures: *const CaptureList = capture_list_pool_get(
        &mut (*self_0).capture_list_pool,
        (*left_state).capture_list_id as uint16_t,
    );
    let mut right_captures: *const CaptureList = capture_list_pool_get(
        &mut (*self_0).capture_list_pool,
        (*right_state).capture_list_id as uint16_t,
    );
    *left_contains_right = 1 as libc::c_int != 0;
    *right_contains_left = 1 as libc::c_int != 0;
    let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    let mut j: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    loop {
        if i < (*left_captures).size {
            if j < (*right_captures).size {
                let mut left: *mut TSQueryCapture =
                    &mut *((*left_captures).contents).offset(i as isize) as *mut TSQueryCapture;
                let mut right: *mut TSQueryCapture =
                    &mut *((*right_captures).contents).offset(j as isize) as *mut TSQueryCapture;
                if (*left).node.id == (*right).node.id && (*left).index == (*right).index {
                    i = i.wrapping_add(1);
                    j = j.wrapping_add(1);
                } else {
                    match ts_query_cursor__compare_nodes((*left).node, (*right).node) {
                        -1 => {
                            *right_contains_left = 0 as libc::c_int != 0;
                            i = i.wrapping_add(1);
                        }
                        1 => {
                            *left_contains_right = 0 as libc::c_int != 0;
                            j = j.wrapping_add(1);
                        }
                        _ => {
                            *right_contains_left = 0 as libc::c_int != 0;
                            *left_contains_right = 0 as libc::c_int != 0;
                            i = i.wrapping_add(1);
                            j = j.wrapping_add(1);
                        }
                    }
                }
            } else {
                *right_contains_left = 0 as libc::c_int != 0;
                break;
            }
        } else {
            if j < (*right_captures).size {
                *left_contains_right = 0 as libc::c_int != 0;
            }
            break;
        }
    }
}
unsafe extern "C" fn ts_query_cursor__add_state(
    mut self_0: *mut TSQueryCursor,
    mut pattern: *const PatternEntry,
) {
    let mut step: *mut QueryStep = &mut *((*(*self_0).query).steps.contents)
        .offset((*pattern).step_index as isize)
        as *mut QueryStep;
    let mut start_depth: uint32_t = ((*self_0).depth).wrapping_sub((*step).depth as libc::c_uint);
    let mut index: uint32_t = (*self_0).states.size;
    while index > 0 as libc::c_int as libc::c_uint {
        let mut prev_state: *mut QueryState = &mut *((*self_0).states.contents)
            .offset(index.wrapping_sub(1 as libc::c_int as libc::c_uint) as isize)
            as *mut QueryState;
        if ((*prev_state).start_depth as libc::c_uint) < start_depth {
            break;
        }
        if (*prev_state).start_depth as libc::c_uint == start_depth {
            if (*prev_state).pattern_index as libc::c_int == (*pattern).pattern_index as libc::c_int
                && (*prev_state).step_index as libc::c_int == (*pattern).step_index as libc::c_int
            {
                return;
            }
            if (*prev_state).pattern_index as libc::c_int <= (*pattern).pattern_index as libc::c_int
            {
                break;
            }
        }
        index = index.wrapping_sub(1);
    }
    _array__splice(
        &mut (*self_0).states as *mut C2RustUnnamed_16 as *mut Array,
        ::core::mem::size_of::<QueryState>() as libc::c_ulong,
        index,
        0 as libc::c_int as uint32_t,
        1 as libc::c_int as uint32_t,
        &mut {
            let mut init = QueryState { consumed_capture_count_seeking_immediate_match_has_in_progress_alternatives_dead_needs_parent : [0 ; 2] , id : 4294967295 as libc :: c_uint , capture_list_id : NONE as uint32_t , start_depth : start_depth as uint16_t , step_index : (* pattern) . step_index , pattern_index : (* pattern) . pattern_index , } ;
            init.set_consumed_capture_count(0 as libc::c_int as uint16_t);
            init.set_seeking_immediate_match(1 as libc::c_int != 0);
            init.set_has_in_progress_alternatives(0 as libc::c_int != 0);
            init.set_dead(0 as libc::c_int != 0);
            init.set_needs_parent((*step).depth as libc::c_int == 1 as libc::c_int);
            init
        } as *mut QueryState as *const libc::c_void,
    );
}
unsafe extern "C" fn ts_query_cursor__prepare_to_capture(
    mut self_0: *mut TSQueryCursor,
    mut state: *mut QueryState,
    mut state_index_to_preserve: libc::c_uint,
) -> *mut CaptureList {
    if (*state).capture_list_id == NONE as libc::c_uint {
        (*state).capture_list_id =
            capture_list_pool_acquire(&mut (*self_0).capture_list_pool) as uint32_t;
        if (*state).capture_list_id == NONE as libc::c_uint {
            (*self_0).did_exceed_match_limit = 1 as libc::c_int != 0;
            let mut state_index: uint32_t = 0;
            let mut byte_offset: uint32_t = 0;
            let mut pattern_index: uint32_t = 0;
            if ts_query_cursor__first_in_progress_capture(
                self_0,
                &mut state_index,
                &mut byte_offset,
                &mut pattern_index,
                0 as *mut bool,
            ) as libc::c_int
                != 0
                && state_index != state_index_to_preserve
            {
                let mut other_state: *mut QueryState = &mut *((*self_0).states.contents)
                    .offset(state_index as isize)
                    as *mut QueryState;
                (*state).capture_list_id = (*other_state).capture_list_id;
                (*other_state).capture_list_id = NONE as uint32_t;
                (*other_state).set_dead(1 as libc::c_int != 0);
                let mut list: *mut CaptureList = capture_list_pool_get_mut(
                    &mut (*self_0).capture_list_pool,
                    (*state).capture_list_id as uint16_t,
                );
                (*list).size = 0 as libc::c_int as uint32_t;
                return list;
            } else {
                return 0 as *mut CaptureList;
            }
        }
    }
    return capture_list_pool_get_mut(
        &mut (*self_0).capture_list_pool,
        (*state).capture_list_id as uint16_t,
    );
}
unsafe extern "C" fn ts_query_cursor__capture(
    mut self_0: *mut TSQueryCursor,
    mut state: *mut QueryState,
    mut step: *mut QueryStep,
    mut node: TSNode,
) {
    if (*state).dead() {
        return;
    }
    let mut capture_list: *mut CaptureList =
        ts_query_cursor__prepare_to_capture(self_0, state, 4294967295 as libc::c_uint);
    if capture_list.is_null() {
        (*state).set_dead(1 as libc::c_int != 0);
        return;
    }
    let mut j: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while j < 3 as libc::c_int as libc::c_uint {
        let mut capture_id: uint16_t = (*step).capture_ids[j as usize];
        if (*step).capture_ids[j as usize] as libc::c_int == NONE as libc::c_int {
            break;
        }
        _array__grow(
            capture_list as *mut Array,
            1 as libc::c_int as uint32_t,
            ::core::mem::size_of::<TSQueryCapture>() as libc::c_ulong,
        );
        let fresh38 = (*capture_list).size;
        (*capture_list).size = ((*capture_list).size).wrapping_add(1);
        *((*capture_list).contents).offset(fresh38 as isize) = {
            let mut init = TSQueryCapture {
                node: node,
                index: capture_id as uint32_t,
            };
            init
        };
        j = j.wrapping_add(1);
    }
}
unsafe extern "C" fn ts_query_cursor__copy_state(
    mut self_0: *mut TSQueryCursor,
    mut state_ref: *mut *mut QueryState,
) -> *mut QueryState {
    let mut state: *const QueryState = *state_ref;
    let mut state_index: uint32_t =
        state.offset_from((*self_0).states.contents) as libc::c_long as uint32_t;
    let mut copy: QueryState = *state;
    copy.capture_list_id = NONE as uint32_t;
    if (*state).capture_list_id != NONE as libc::c_uint {
        let mut new_captures: *mut CaptureList =
            ts_query_cursor__prepare_to_capture(self_0, &mut copy, state_index);
        if new_captures.is_null() {
            return 0 as *mut QueryState;
        }
        let mut old_captures: *const CaptureList = capture_list_pool_get(
            &mut (*self_0).capture_list_pool,
            (*state).capture_list_id as uint16_t,
        );
        _array__splice(
            new_captures as *mut Array,
            ::core::mem::size_of::<TSQueryCapture>() as libc::c_ulong,
            (*new_captures).size,
            0 as libc::c_int as uint32_t,
            (*old_captures).size,
            (*old_captures).contents as *const libc::c_void,
        );
    }
    _array__splice(
        &mut (*self_0).states as *mut C2RustUnnamed_16 as *mut Array,
        ::core::mem::size_of::<QueryState>() as libc::c_ulong,
        state_index.wrapping_add(1 as libc::c_int as libc::c_uint),
        0 as libc::c_int as uint32_t,
        1 as libc::c_int as uint32_t,
        &mut copy as *mut QueryState as *const libc::c_void,
    );
    *state_ref = &mut *((*self_0).states.contents).offset(state_index as isize) as *mut QueryState;
    return &mut *((*self_0).states.contents)
        .offset(state_index.wrapping_add(1 as libc::c_int as libc::c_uint) as isize)
        as *mut QueryState;
}
#[inline]
unsafe extern "C" fn ts_query_cursor__should_descend(
    mut self_0: *mut TSQueryCursor,
    mut node_intersects_range: bool,
) -> bool {
    if node_intersects_range as libc::c_int != 0 && (*self_0).depth < (*self_0).max_start_depth {
        return 1 as libc::c_int != 0;
    }
    let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i < (*self_0).states.size {
        let mut state: *mut QueryState =
            &mut *((*self_0).states.contents).offset(i as isize) as *mut QueryState;
        let mut next_step: *mut QueryStep = &mut *((*(*self_0).query).steps.contents)
            .offset((*state).step_index as isize)
            as *mut QueryStep;
        if (*next_step).depth as libc::c_int != PATTERN_DONE_MARKER as libc::c_int
            && ((*state).start_depth as libc::c_int + (*next_step).depth as libc::c_int)
                as libc::c_uint
                > (*self_0).depth
        {
            return 1 as libc::c_int != 0;
        }
        i = i.wrapping_add(1);
    }
    if (*self_0).depth >= (*self_0).max_start_depth {
        return 0 as libc::c_int != 0;
    }
    if !(*self_0).on_visible_node {
        let mut subtree: Subtree = ts_tree_cursor_current_subtree(&mut (*self_0).cursor);
        if ts_subtree_is_repetition(subtree) != 0 {
            let mut exists: bool = false;
            let mut index: uint32_t = 0;
            index = 0 as libc::c_int as uint32_t;
            exists = 0 as libc::c_int != 0;
            let mut size: uint32_t = ((*(*self_0).query)
                .repeat_symbols_with_rootless_patterns
                .size)
                .wrapping_sub(index);
            if !(size == 0 as libc::c_int as libc::c_uint) {
                let mut comparison: libc::c_int = 0;
                while size > 1 as libc::c_int as libc::c_uint {
                    let mut half_size: uint32_t =
                        size.wrapping_div(2 as libc::c_int as libc::c_uint);
                    let mut mid_index: uint32_t = index.wrapping_add(half_size);
                    comparison = *((*(*self_0).query)
                        .repeat_symbols_with_rootless_patterns
                        .contents)
                        .offset(mid_index as isize) as libc::c_int
                        - ts_subtree_symbol(subtree) as libc::c_int;
                    if comparison <= 0 as libc::c_int {
                        index = mid_index;
                    }
                    size = (size as libc::c_uint).wrapping_sub(half_size) as uint32_t as uint32_t;
                }
                comparison = *((*(*self_0).query)
                    .repeat_symbols_with_rootless_patterns
                    .contents)
                    .offset(index as isize) as libc::c_int
                    - ts_subtree_symbol(subtree) as libc::c_int;
                if comparison == 0 as libc::c_int {
                    exists = 1 as libc::c_int != 0;
                } else if comparison < 0 as libc::c_int {
                    index = (index as libc::c_uint).wrapping_add(1 as libc::c_int as libc::c_uint)
                        as uint32_t as uint32_t;
                }
            }
            return exists;
        }
        return 1 as libc::c_int != 0;
    }
    return 0 as libc::c_int != 0;
}
#[inline]
unsafe extern "C" fn ts_query_cursor__advance(
    mut self_0: *mut TSQueryCursor,
    mut stop_on_definite_step: bool,
) -> bool {
    let mut did_match: bool = 0 as libc::c_int != 0;
    let mut current_block_189: u64;
    loop {
        if (*self_0).halted {
            while (*self_0).states.size > 0 as libc::c_int as libc::c_uint {
                (*self_0).states.size = ((*self_0).states.size).wrapping_sub(1);
                let mut state: QueryState =
                    *((*self_0).states.contents).offset((*self_0).states.size as isize);
                capture_list_pool_release(
                    &mut (*self_0).capture_list_pool,
                    state.capture_list_id as uint16_t,
                );
            }
        }
        (*self_0).operation_count = ((*self_0).operation_count).wrapping_add(1);
        if (*self_0).operation_count == OP_COUNT_PER_QUERY_TIMEOUT_CHECK {
            (*self_0).operation_count = 0 as libc::c_int as libc::c_uint;
        }
        if did_match as libc::c_int != 0
            || (*self_0).halted as libc::c_int != 0
            || (*self_0).operation_count == 0 as libc::c_int as libc::c_uint
                && !clock_is_null((*self_0).end_clock)
                && clock_is_gt(clock_now(), (*self_0).end_clock) as libc::c_int != 0
        {
            return did_match;
        }
        if (*self_0).ascending {
            if (*self_0).on_visible_node {
                let mut deleted_count: uint32_t = 0 as libc::c_int as uint32_t;
                let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
                let mut n: libc::c_uint = (*self_0).states.size;
                while i < n {
                    let mut state_0: *mut QueryState =
                        &mut *((*self_0).states.contents).offset(i as isize) as *mut QueryState;
                    let mut step: *mut QueryStep = &mut *((*(*self_0).query).steps.contents)
                        .offset((*state_0).step_index as isize)
                        as *mut QueryStep;
                    if (*step).depth as libc::c_int == PATTERN_DONE_MARKER as libc::c_int
                        && ((*state_0).start_depth as libc::c_uint > (*self_0).depth
                            || (*self_0).depth == 0 as libc::c_int as libc::c_uint)
                    {
                        _array__grow(
                            &mut (*self_0).finished_states as *mut C2RustUnnamed_15 as *mut Array,
                            1 as libc::c_int as uint32_t,
                            ::core::mem::size_of::<QueryState>() as libc::c_ulong,
                        );
                        let fresh39 = (*self_0).finished_states.size;
                        (*self_0).finished_states.size =
                            ((*self_0).finished_states.size).wrapping_add(1);
                        *((*self_0).finished_states.contents).offset(fresh39 as isize) = *state_0;
                        did_match = 1 as libc::c_int != 0;
                        deleted_count = deleted_count.wrapping_add(1);
                    } else if (*step).depth as libc::c_int != PATTERN_DONE_MARKER as libc::c_int
                        && ((*state_0).start_depth as uint32_t)
                            .wrapping_add((*step).depth as uint32_t)
                            > (*self_0).depth
                    {
                        capture_list_pool_release(
                            &mut (*self_0).capture_list_pool,
                            (*state_0).capture_list_id as uint16_t,
                        );
                        deleted_count = deleted_count.wrapping_add(1);
                    } else if deleted_count > 0 as libc::c_int as libc::c_uint {
                        *((*self_0).states.contents)
                            .offset(i.wrapping_sub(deleted_count) as isize) = *state_0;
                    }
                    i = i.wrapping_add(1);
                }
                (*self_0).states.size = ((*self_0).states.size as libc::c_uint)
                    .wrapping_sub(deleted_count) as uint32_t
                    as uint32_t;
            }
            match ts_tree_cursor_goto_next_sibling_internal(&mut (*self_0).cursor) as libc::c_uint {
                2 => {
                    if !(*self_0).on_visible_node {
                        (*self_0).depth = ((*self_0).depth).wrapping_add(1);
                        (*self_0).on_visible_node = 1 as libc::c_int != 0;
                    }
                    (*self_0).ascending = 0 as libc::c_int != 0;
                }
                1 => {
                    if (*self_0).on_visible_node {
                        (*self_0).depth = ((*self_0).depth).wrapping_sub(1);
                        (*self_0).on_visible_node = 0 as libc::c_int != 0;
                    }
                    (*self_0).ascending = 0 as libc::c_int != 0;
                }
                _ => {
                    if ts_tree_cursor_goto_parent(&mut (*self_0).cursor) {
                        (*self_0).depth = ((*self_0).depth).wrapping_sub(1);
                    } else {
                        (*self_0).halted = 1 as libc::c_int != 0;
                    }
                }
            }
        } else {
            let mut node: TSNode = ts_tree_cursor_current_node(&mut (*self_0).cursor);
            let mut parent_node: TSNode = ts_tree_cursor_parent_node(&mut (*self_0).cursor);
            let mut start_byte: uint32_t = ts_node_start_byte(node);
            let mut end_byte: uint32_t = ts_node_end_byte(node);
            let mut start_point: TSPoint = ts_node_start_point(node);
            let mut end_point: TSPoint = ts_node_end_point(node);
            let mut is_empty: bool = start_byte == end_byte;
            let mut parent_precedes_range: bool = !ts_node_is_null(parent_node)
                && (ts_node_end_byte(parent_node) <= (*self_0).start_byte
                    || point_lte(ts_node_end_point(parent_node), (*self_0).start_point)
                        as libc::c_int
                        != 0);
            let mut parent_follows_range: bool = !ts_node_is_null(parent_node)
                && (ts_node_start_byte(parent_node) >= (*self_0).end_byte
                    || point_gte(ts_node_start_point(parent_node), (*self_0).end_point)
                        as libc::c_int
                        != 0);
            let mut node_precedes_range: bool = parent_precedes_range as libc::c_int != 0
                || end_byte < (*self_0).start_byte
                || point_lt(end_point, (*self_0).start_point) as libc::c_int != 0
                || !is_empty && end_byte == (*self_0).start_byte
                || !is_empty && point_eq(end_point, (*self_0).start_point) as libc::c_int != 0;
            let mut node_follows_range: bool = parent_follows_range as libc::c_int != 0
                || (start_byte >= (*self_0).end_byte
                    || point_gte(start_point, (*self_0).end_point) as libc::c_int != 0);
            let mut parent_intersects_range: bool = !parent_precedes_range && !parent_follows_range;
            let mut node_intersects_range: bool = !node_precedes_range && !node_follows_range;
            if (*self_0).on_visible_node {
                let mut symbol: TSSymbol = ts_node_symbol(node);
                let mut is_named: bool = ts_node_is_named(node);
                let mut has_later_siblings: bool = false;
                let mut has_later_named_siblings: bool = false;
                let mut can_have_later_siblings_with_this_field: bool = false;
                let mut field_id: TSFieldId = 0 as libc::c_int as TSFieldId;
                let mut supertypes: [TSSymbol; 8] =
                    [0 as libc::c_int as TSSymbol, 0, 0, 0, 0, 0, 0, 0];
                let mut supertype_count: libc::c_uint = 8 as libc::c_int as libc::c_uint;
                ts_tree_cursor_current_status(
                    &mut (*self_0).cursor,
                    &mut field_id,
                    &mut has_later_siblings,
                    &mut has_later_named_siblings,
                    &mut can_have_later_siblings_with_this_field,
                    supertypes.as_mut_ptr(),
                    &mut supertype_count,
                );
                let mut node_is_error: bool =
                    symbol as libc::c_int == -(1 as libc::c_int) as TSSymbol as libc::c_int;
                let mut parent_is_error: bool = !ts_node_is_null(parent_node)
                    && ts_node_symbol(parent_node) as libc::c_int
                        == -(1 as libc::c_int) as TSSymbol as libc::c_int;
                if !node_is_error {
                    let mut i_0: libc::c_uint = 0 as libc::c_int as libc::c_uint;
                    while i_0 < (*(*self_0).query).wildcard_root_pattern_count as libc::c_uint {
                        let mut pattern: *mut PatternEntry =
                            &mut *((*(*self_0).query).pattern_map.contents).offset(i_0 as isize)
                                as *mut PatternEntry;
                        let mut step_0: *mut QueryStep = &mut *((*(*self_0).query).steps.contents)
                            .offset((*pattern).step_index as isize)
                            as *mut QueryStep;
                        let mut start_depth: uint32_t =
                            ((*self_0).depth).wrapping_sub((*step_0).depth as libc::c_uint);
                        if (if (*pattern).is_rooted as libc::c_int != 0 {
                            node_intersects_range as libc::c_int
                        } else {
                            (parent_intersects_range as libc::c_int != 0 && !parent_is_error)
                                as libc::c_int
                        }) != 0
                            && ((*step_0).field == 0
                                || field_id as libc::c_int == (*step_0).field as libc::c_int)
                            && ((*step_0).supertype_symbol == 0
                                || supertype_count > 0 as libc::c_int as libc::c_uint)
                            && start_depth <= (*self_0).max_start_depth
                        {
                            ts_query_cursor__add_state(self_0, pattern);
                        }
                        i_0 = i_0.wrapping_add(1);
                    }
                }
                let mut i_1: libc::c_uint = 0;
                if ts_query__pattern_map_search((*self_0).query, symbol, &mut i_1) {
                    let mut pattern_0: *mut PatternEntry =
                        &mut *((*(*self_0).query).pattern_map.contents).offset(i_1 as isize)
                            as *mut PatternEntry;
                    let mut step_1: *mut QueryStep = &mut *((*(*self_0).query).steps.contents)
                        .offset((*pattern_0).step_index as isize)
                        as *mut QueryStep;
                    let mut start_depth_0: uint32_t =
                        ((*self_0).depth).wrapping_sub((*step_1).depth as libc::c_uint);
                    loop {
                        if (if (*pattern_0).is_rooted as libc::c_int != 0 {
                            node_intersects_range as libc::c_int
                        } else {
                            (parent_intersects_range as libc::c_int != 0 && !parent_is_error)
                                as libc::c_int
                        }) != 0
                            && ((*step_1).field == 0
                                || field_id as libc::c_int == (*step_1).field as libc::c_int)
                            && start_depth_0 <= (*self_0).max_start_depth
                        {
                            ts_query_cursor__add_state(self_0, pattern_0);
                        }
                        i_1 = i_1.wrapping_add(1);
                        if i_1 == (*(*self_0).query).pattern_map.size {
                            break;
                        }
                        pattern_0 = &mut *((*(*self_0).query).pattern_map.contents)
                            .offset(i_1 as isize)
                            as *mut PatternEntry;
                        step_1 = &mut *((*(*self_0).query).steps.contents)
                            .offset((*pattern_0).step_index as isize)
                            as *mut QueryStep;
                        if !((*step_1).symbol as libc::c_int == symbol as libc::c_int) {
                            break;
                        }
                    }
                }
                let mut j: libc::c_uint = 0 as libc::c_int as libc::c_uint;
                let mut copy_count: libc::c_uint = 0 as libc::c_int as libc::c_uint;
                while j < (*self_0).states.size {
                    let mut state_1: *mut QueryState =
                        &mut *((*self_0).states.contents).offset(j as isize) as *mut QueryState;
                    let mut step_2: *mut QueryStep = &mut *((*(*self_0).query).steps.contents)
                        .offset((*state_1).step_index as isize)
                        as *mut QueryStep;
                    (*state_1).set_has_in_progress_alternatives(0 as libc::c_int != 0);
                    copy_count = 0 as libc::c_int as libc::c_uint;
                    if !(((*state_1).start_depth as uint32_t)
                        .wrapping_add((*step_2).depth as uint32_t)
                        != (*self_0).depth)
                    {
                        let mut node_does_match: bool = 0 as libc::c_int != 0;
                        if (*step_2).symbol as libc::c_int == WILDCARD_SYMBOL as libc::c_int {
                            node_does_match = !node_is_error
                                && (is_named as libc::c_int != 0 || !(*step_2).is_named());
                        } else {
                            node_does_match =
                                symbol as libc::c_int == (*step_2).symbol as libc::c_int;
                        }
                        let mut later_sibling_can_match: bool = has_later_siblings;
                        if (*step_2).is_immediate() as libc::c_int != 0
                            && is_named as libc::c_int != 0
                            || (*state_1).seeking_immediate_match() as libc::c_int != 0
                        {
                            later_sibling_can_match = 0 as libc::c_int != 0;
                        }
                        if (*step_2).is_last_child() as libc::c_int != 0
                            && has_later_named_siblings as libc::c_int != 0
                        {
                            node_does_match = 0 as libc::c_int != 0;
                        }
                        if (*step_2).supertype_symbol != 0 {
                            let mut has_supertype: bool = 0 as libc::c_int != 0;
                            let mut k: libc::c_uint = 0 as libc::c_int as libc::c_uint;
                            while k < supertype_count {
                                if supertypes[k as usize] as libc::c_int
                                    == (*step_2).supertype_symbol as libc::c_int
                                {
                                    has_supertype = 1 as libc::c_int != 0;
                                    break;
                                } else {
                                    k = k.wrapping_add(1);
                                }
                            }
                            if !has_supertype {
                                node_does_match = 0 as libc::c_int != 0;
                            }
                        }
                        if (*step_2).field != 0 {
                            if (*step_2).field as libc::c_int == field_id as libc::c_int {
                                if !can_have_later_siblings_with_this_field {
                                    later_sibling_can_match = 0 as libc::c_int != 0;
                                }
                            } else {
                                node_does_match = 0 as libc::c_int != 0;
                            }
                        }
                        if (*step_2).negated_field_list_id != 0 {
                            let mut negated_field_ids: *mut TSFieldId =
                                &mut *((*(*self_0).query).negated_fields.contents)
                                    .offset((*step_2).negated_field_list_id as isize)
                                    as *mut TSFieldId;
                            loop {
                                let mut negated_field_id: TSFieldId = *negated_field_ids;
                                if !(negated_field_id != 0) {
                                    break;
                                }
                                negated_field_ids = negated_field_ids.offset(1);
                                if ((ts_node_child_by_field_id(node, negated_field_id)).id)
                                    .is_null()
                                {
                                    continue;
                                }
                                node_does_match = 0 as libc::c_int != 0;
                                break;
                            }
                        }
                        if !node_does_match {
                            if !later_sibling_can_match {
                                capture_list_pool_release(
                                    &mut (*self_0).capture_list_pool,
                                    (*state_1).capture_list_id as uint16_t,
                                );
                                _array__erase(
                                    &mut (*self_0).states as *mut C2RustUnnamed_16 as *mut Array,
                                    ::core::mem::size_of::<QueryState>() as libc::c_ulong,
                                    j,
                                );
                                j = j.wrapping_sub(1);
                            }
                        } else {
                            if later_sibling_can_match as libc::c_int != 0
                                && ((*step_2).contains_captures() as libc::c_int != 0
                                    || ts_query__step_is_fallible(
                                        (*self_0).query,
                                        (*state_1).step_index,
                                    ) as libc::c_int
                                        != 0)
                            {
                                if !(ts_query_cursor__copy_state(self_0, &mut state_1)).is_null() {
                                    copy_count = copy_count.wrapping_add(1);
                                }
                            }
                            if (*state_1).needs_parent() {
                                let mut parent: TSNode =
                                    ts_tree_cursor_parent_node(&mut (*self_0).cursor);
                                if ts_node_is_null(parent) {
                                    (*state_1).set_dead(1 as libc::c_int != 0);
                                } else {
                                    (*state_1).set_needs_parent(0 as libc::c_int != 0);
                                    let mut skipped_wildcard_step: *mut QueryStep = step_2;
                                    loop {
                                        skipped_wildcard_step = skipped_wildcard_step.offset(-1);
                                        if !((*skipped_wildcard_step).is_dead_end() as libc::c_int
                                            != 0
                                            || (*skipped_wildcard_step).is_pass_through()
                                                as libc::c_int
                                                != 0
                                            || (*skipped_wildcard_step).depth as libc::c_int
                                                > 0 as libc::c_int)
                                        {
                                            break;
                                        }
                                    }
                                    if (*skipped_wildcard_step).capture_ids
                                        [0 as libc::c_int as usize]
                                        as libc::c_int
                                        != NONE as libc::c_int
                                    {
                                        ts_query_cursor__capture(
                                            self_0,
                                            state_1,
                                            skipped_wildcard_step,
                                            parent,
                                        );
                                    }
                                }
                            }
                            if (*step_2).capture_ids[0 as libc::c_int as usize] as libc::c_int
                                != NONE as libc::c_int
                            {
                                ts_query_cursor__capture(self_0, state_1, step_2, node);
                            }
                            if (*state_1).dead() {
                                _array__erase(
                                    &mut (*self_0).states as *mut C2RustUnnamed_16 as *mut Array,
                                    ::core::mem::size_of::<QueryState>() as libc::c_ulong,
                                    j,
                                );
                                j = j.wrapping_sub(1);
                            } else {
                                (*state_1).step_index = ((*state_1).step_index).wrapping_add(1);
                                (*state_1).set_seeking_immediate_match(0 as libc::c_int != 0);
                                let mut next_step: *mut QueryStep =
                                    &mut *((*(*self_0).query).steps.contents)
                                        .offset((*state_1).step_index as isize)
                                        as *mut QueryStep;
                                if stop_on_definite_step as libc::c_int != 0
                                    && (*next_step).root_pattern_guaranteed() as libc::c_int != 0
                                {
                                    did_match = 1 as libc::c_int != 0;
                                }
                                let mut end_index: libc::c_uint =
                                    j.wrapping_add(1 as libc::c_int as libc::c_uint);
                                let mut k_0: libc::c_uint = j;
                                while k_0 < end_index {
                                    let mut child_state: *mut QueryState =
                                        &mut *((*self_0).states.contents).offset(k_0 as isize)
                                            as *mut QueryState;
                                    let mut child_step: *mut QueryStep =
                                        &mut *((*(*self_0).query).steps.contents)
                                            .offset((*child_state).step_index as isize)
                                            as *mut QueryStep;
                                    if (*child_step).alternative_index as libc::c_int
                                        != NONE as libc::c_int
                                    {
                                        if (*child_step).is_dead_end() {
                                            (*child_state).step_index =
                                                (*child_step).alternative_index;
                                            k_0 = k_0.wrapping_sub(1);
                                        } else {
                                            if (*child_step).is_pass_through() {
                                                (*child_state).step_index =
                                                    ((*child_state).step_index).wrapping_add(1);
                                                k_0 = k_0.wrapping_sub(1);
                                            }
                                            let mut copy: *mut QueryState =
                                                ts_query_cursor__copy_state(
                                                    self_0,
                                                    &mut child_state,
                                                );
                                            if !copy.is_null() {
                                                end_index = end_index.wrapping_add(1);
                                                copy_count = copy_count.wrapping_add(1);
                                                (*copy).step_index =
                                                    (*child_step).alternative_index;
                                                if (*child_step).alternative_is_immediate() {
                                                    (*copy).set_seeking_immediate_match(
                                                        1 as libc::c_int != 0,
                                                    );
                                                }
                                            }
                                        }
                                    }
                                    k_0 = k_0.wrapping_add(1);
                                }
                            }
                        }
                    }
                    j = j.wrapping_add((1 as libc::c_int as libc::c_uint).wrapping_add(copy_count));
                }
                let mut j_0: libc::c_uint = 0 as libc::c_int as libc::c_uint;
                while j_0 < (*self_0).states.size {
                    let mut state_2: *mut QueryState =
                        &mut *((*self_0).states.contents).offset(j_0 as isize) as *mut QueryState;
                    if (*state_2).dead() {
                        _array__erase(
                            &mut (*self_0).states as *mut C2RustUnnamed_16 as *mut Array,
                            ::core::mem::size_of::<QueryState>() as libc::c_ulong,
                            j_0,
                        );
                        j_0 = j_0.wrapping_sub(1);
                    } else {
                        let mut did_remove: bool = 0 as libc::c_int != 0;
                        let mut current_block_167: u64;
                        let mut k_1: libc::c_uint =
                            j_0.wrapping_add(1 as libc::c_int as libc::c_uint);
                        while k_1 < (*self_0).states.size {
                            let mut other_state: *mut QueryState = &mut *((*self_0).states.contents)
                                .offset(k_1 as isize)
                                as *mut QueryState;
                            if (*other_state).start_depth as libc::c_int
                                != (*state_2).start_depth as libc::c_int
                                || (*other_state).pattern_index as libc::c_int
                                    != (*state_2).pattern_index as libc::c_int
                            {
                                break;
                            }
                            let mut left_contains_right: bool = false;
                            let mut right_contains_left: bool = false;
                            ts_query_cursor__compare_captures(
                                self_0,
                                state_2,
                                other_state,
                                &mut left_contains_right,
                                &mut right_contains_left,
                            );
                            if left_contains_right {
                                if (*state_2).step_index as libc::c_int
                                    == (*other_state).step_index as libc::c_int
                                {
                                    capture_list_pool_release(
                                        &mut (*self_0).capture_list_pool,
                                        (*other_state).capture_list_id as uint16_t,
                                    );
                                    _array__erase(
                                        &mut (*self_0).states as *mut C2RustUnnamed_16
                                            as *mut Array,
                                        ::core::mem::size_of::<QueryState>() as libc::c_ulong,
                                        k_1,
                                    );
                                    k_1 = k_1.wrapping_sub(1);
                                    current_block_167 = 145651165234646754;
                                } else {
                                    (*other_state)
                                        .set_has_in_progress_alternatives(1 as libc::c_int != 0);
                                    current_block_167 = 10485226111480991281;
                                }
                            } else {
                                current_block_167 = 10485226111480991281;
                            }
                            match current_block_167 {
                                10485226111480991281 => {
                                    if right_contains_left {
                                        if (*state_2).step_index as libc::c_int
                                            == (*other_state).step_index as libc::c_int
                                        {
                                            capture_list_pool_release(
                                                &mut (*self_0).capture_list_pool,
                                                (*state_2).capture_list_id as uint16_t,
                                            );
                                            _array__erase(
                                                &mut (*self_0).states as *mut C2RustUnnamed_16
                                                    as *mut Array,
                                                ::core::mem::size_of::<QueryState>()
                                                    as libc::c_ulong,
                                                j_0,
                                            );
                                            j_0 = j_0.wrapping_sub(1);
                                            did_remove = 1 as libc::c_int != 0;
                                            break;
                                        } else {
                                            (*state_2).set_has_in_progress_alternatives(
                                                1 as libc::c_int != 0,
                                            );
                                        }
                                    }
                                }
                                _ => {}
                            }
                            k_1 = k_1.wrapping_add(1);
                        }
                        if !did_remove {
                            let mut next_step_0: *mut QueryStep =
                                &mut *((*(*self_0).query).steps.contents)
                                    .offset((*state_2).step_index as isize)
                                    as *mut QueryStep;
                            if (*next_step_0).depth as libc::c_int
                                == PATTERN_DONE_MARKER as libc::c_int
                            {
                                if !(*state_2).has_in_progress_alternatives() {
                                    _array__grow(
                                        &mut (*self_0).finished_states as *mut C2RustUnnamed_15
                                            as *mut Array,
                                        1 as libc::c_int as uint32_t,
                                        ::core::mem::size_of::<QueryState>() as libc::c_ulong,
                                    );
                                    let fresh40 = (*self_0).finished_states.size;
                                    (*self_0).finished_states.size =
                                        ((*self_0).finished_states.size).wrapping_add(1);
                                    *((*self_0).finished_states.contents)
                                        .offset(fresh40 as isize) = *state_2;
                                    _array__erase(
                                        &mut (*self_0).states as *mut C2RustUnnamed_16
                                            as *mut Array,
                                        ::core::mem::size_of::<QueryState>() as libc::c_ulong,
                                        state_2.offset_from((*self_0).states.contents)
                                            as libc::c_long
                                            as uint32_t,
                                    );
                                    did_match = 1 as libc::c_int != 0;
                                    j_0 = j_0.wrapping_sub(1);
                                }
                            }
                        }
                    }
                    j_0 = j_0.wrapping_add(1);
                }
            }
            if ts_query_cursor__should_descend(self_0, node_intersects_range) {
                match ts_tree_cursor_goto_first_child_internal(&mut (*self_0).cursor)
                    as libc::c_uint
                {
                    2 => {
                        current_block_189 = 10043285778187427915;
                        match current_block_189 {
                            17416027944940096235 => {
                                (*self_0).on_visible_node = 0 as libc::c_int != 0;
                                continue;
                            }
                            _ => {
                                (*self_0).depth = ((*self_0).depth).wrapping_add(1);
                                (*self_0).on_visible_node = 1 as libc::c_int != 0;
                                continue;
                            }
                        }
                    }
                    1 => {
                        current_block_189 = 17416027944940096235;
                        match current_block_189 {
                            17416027944940096235 => {
                                (*self_0).on_visible_node = 0 as libc::c_int != 0;
                                continue;
                            }
                            _ => {
                                (*self_0).depth = ((*self_0).depth).wrapping_add(1);
                                (*self_0).on_visible_node = 1 as libc::c_int != 0;
                                continue;
                            }
                        }
                    }
                    _ => {}
                }
            }
            (*self_0).ascending = 1 as libc::c_int != 0;
        }
    }
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_cursor_next_match(
    mut self_0: *mut TSQueryCursor,
    mut match_0: *mut TSQueryMatch,
) -> bool {
    if (*self_0).finished_states.size == 0 as libc::c_int as libc::c_uint {
        if !ts_query_cursor__advance(self_0, 0 as libc::c_int != 0) {
            return 0 as libc::c_int != 0;
        }
    }
    let mut state: *mut QueryState = &mut *((*self_0).finished_states.contents)
        .offset(0 as libc::c_int as isize) as *mut QueryState;
    if (*state).id == 4294967295 as libc::c_uint {
        let fresh41 = (*self_0).next_state_id;
        (*self_0).next_state_id = ((*self_0).next_state_id).wrapping_add(1);
        (*state).id = fresh41;
    }
    (*match_0).id = (*state).id;
    (*match_0).pattern_index = (*state).pattern_index;
    let mut captures: *const CaptureList = capture_list_pool_get(
        &mut (*self_0).capture_list_pool,
        (*state).capture_list_id as uint16_t,
    );
    (*match_0).captures = (*captures).contents;
    (*match_0).capture_count = (*captures).size as uint16_t;
    capture_list_pool_release(
        &mut (*self_0).capture_list_pool,
        (*state).capture_list_id as uint16_t,
    );
    _array__erase(
        &mut (*self_0).finished_states as *mut C2RustUnnamed_15 as *mut Array,
        ::core::mem::size_of::<QueryState>() as libc::c_ulong,
        0 as libc::c_int as uint32_t,
    );
    return 1 as libc::c_int != 0;
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_cursor_remove_match(
    mut self_0: *mut TSQueryCursor,
    mut match_id: uint32_t,
) {
    let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i < (*self_0).finished_states.size {
        let mut state: *const QueryState =
            &mut *((*self_0).finished_states.contents).offset(i as isize) as *mut QueryState;
        if (*state).id == match_id {
            capture_list_pool_release(
                &mut (*self_0).capture_list_pool,
                (*state).capture_list_id as uint16_t,
            );
            _array__erase(
                &mut (*self_0).finished_states as *mut C2RustUnnamed_15 as *mut Array,
                ::core::mem::size_of::<QueryState>() as libc::c_ulong,
                i,
            );
            return;
        }
        i = i.wrapping_add(1);
    }
    let mut i_0: libc::c_uint = 0 as libc::c_int as libc::c_uint;
    while i_0 < (*self_0).states.size {
        let mut state_0: *const QueryState =
            &mut *((*self_0).states.contents).offset(i_0 as isize) as *mut QueryState;
        if (*state_0).id == match_id {
            capture_list_pool_release(
                &mut (*self_0).capture_list_pool,
                (*state_0).capture_list_id as uint16_t,
            );
            _array__erase(
                &mut (*self_0).states as *mut C2RustUnnamed_16 as *mut Array,
                ::core::mem::size_of::<QueryState>() as libc::c_ulong,
                i_0,
            );
            return;
        }
        i_0 = i_0.wrapping_add(1);
    }
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_cursor_next_capture(
    mut self_0: *mut TSQueryCursor,
    mut match_0: *mut TSQueryMatch,
    mut capture_index: *mut uint32_t,
) -> bool {
    loop {
        let mut first_unfinished_capture_byte: uint32_t = 0;
        let mut first_unfinished_pattern_index: uint32_t = 0;
        let mut first_unfinished_state_index: uint32_t = 0;
        let mut first_unfinished_state_is_definite: bool = 0 as libc::c_int != 0;
        let mut found_unfinished_state: bool = ts_query_cursor__first_in_progress_capture(
            self_0,
            &mut first_unfinished_state_index,
            &mut first_unfinished_capture_byte,
            &mut first_unfinished_pattern_index,
            &mut first_unfinished_state_is_definite,
        );
        let mut first_finished_state: *mut QueryState = 0 as *mut QueryState;
        let mut first_finished_capture_byte: uint32_t = first_unfinished_capture_byte;
        let mut first_finished_pattern_index: uint32_t = first_unfinished_pattern_index;
        let mut i: libc::c_uint = 0 as libc::c_int as libc::c_uint;
        while i < (*self_0).finished_states.size {
            let mut state: *mut QueryState =
                &mut *((*self_0).finished_states.contents).offset(i as isize) as *mut QueryState;
            let mut captures: *const CaptureList = capture_list_pool_get(
                &mut (*self_0).capture_list_pool,
                (*state).capture_list_id as uint16_t,
            );
            if (*state).consumed_capture_count() as libc::c_uint >= (*captures).size {
                capture_list_pool_release(
                    &mut (*self_0).capture_list_pool,
                    (*state).capture_list_id as uint16_t,
                );
                _array__erase(
                    &mut (*self_0).finished_states as *mut C2RustUnnamed_15 as *mut Array,
                    ::core::mem::size_of::<QueryState>() as libc::c_ulong,
                    i,
                );
            } else {
                let mut node: TSNode = (*((*captures).contents)
                    .offset((*state).consumed_capture_count() as isize))
                .node;
                let mut node_precedes_range: bool = ts_node_end_byte(node) <= (*self_0).start_byte
                    || point_lte(ts_node_end_point(node), (*self_0).start_point) as libc::c_int
                        != 0;
                let mut node_follows_range: bool = ts_node_start_byte(node) >= (*self_0).end_byte
                    || point_gte(ts_node_start_point(node), (*self_0).end_point) as libc::c_int
                        != 0;
                let mut node_outside_of_range: bool = node_precedes_range as libc::c_int != 0
                    || node_follows_range as libc::c_int != 0;
                if node_outside_of_range {
                    (*state).set_consumed_capture_count((*state).consumed_capture_count() + 1);
                } else {
                    let mut node_start_byte: uint32_t = ts_node_start_byte(node);
                    if node_start_byte < first_finished_capture_byte
                        || node_start_byte == first_finished_capture_byte
                            && ((*state).pattern_index as libc::c_uint)
                                < first_finished_pattern_index
                    {
                        first_finished_state = state;
                        first_finished_capture_byte = node_start_byte;
                        first_finished_pattern_index = (*state).pattern_index as uint32_t;
                    }
                    i = i.wrapping_add(1);
                }
            }
        }
        let mut state_0: *mut QueryState = 0 as *mut QueryState;
        if !first_finished_state.is_null() {
            state_0 = first_finished_state;
        } else if first_unfinished_state_is_definite {
            state_0 = &mut *((*self_0).states.contents)
                .offset(first_unfinished_state_index as isize)
                as *mut QueryState;
        } else {
            state_0 = 0 as *mut QueryState;
        }
        if !state_0.is_null() {
            if (*state_0).id == 4294967295 as libc::c_uint {
                let fresh42 = (*self_0).next_state_id;
                (*self_0).next_state_id = ((*self_0).next_state_id).wrapping_add(1);
                (*state_0).id = fresh42;
            }
            (*match_0).id = (*state_0).id;
            (*match_0).pattern_index = (*state_0).pattern_index;
            let mut captures_0: *const CaptureList = capture_list_pool_get(
                &mut (*self_0).capture_list_pool,
                (*state_0).capture_list_id as uint16_t,
            );
            (*match_0).captures = (*captures_0).contents;
            (*match_0).capture_count = (*captures_0).size as uint16_t;
            *capture_index = (*state_0).consumed_capture_count() as uint32_t;
            (*state_0).set_consumed_capture_count((*state_0).consumed_capture_count() + 1);
            return 1 as libc::c_int != 0;
        }
        if capture_list_pool_is_empty(&mut (*self_0).capture_list_pool) as libc::c_int != 0
            && found_unfinished_state as libc::c_int != 0
        {
            capture_list_pool_release(
                &mut (*self_0).capture_list_pool,
                (*((*self_0).states.contents).offset(first_unfinished_state_index as isize))
                    .capture_list_id as uint16_t,
            );
            _array__erase(
                &mut (*self_0).states as *mut C2RustUnnamed_16 as *mut Array,
                ::core::mem::size_of::<QueryState>() as libc::c_ulong,
                first_unfinished_state_index,
            );
        }
        if !ts_query_cursor__advance(self_0, 1 as libc::c_int != 0)
            && (*self_0).finished_states.size == 0 as libc::c_int as libc::c_uint
        {
            return 0 as libc::c_int != 0;
        }
    }
}
#[no_mangle]
pub unsafe extern "C" fn ts_query_cursor_set_max_start_depth(
    mut self_0: *mut TSQueryCursor,
    mut max_start_depth: uint32_t,
) {
    (*self_0).max_start_depth = max_start_depth;
}
pub const TreeCursorStep_TreeCursorStepHidden: TreeCursorStep = TreeCursorStepHidden;
pub const TreeCursorStep_TreeCursorStepVisible: TreeCursorStep = TreeCursorStepVisible;
pub const TreeCursorStep_TreeCursorStepNone: TreeCursorStep = TreeCursorStepNone;