use crate::externs::{
    free, malloc, memcpy, memmove, memset, realloc, strdup, strlen,
};
use crate::ops::{ForceAdd as _, ForceMul as _};
use crate::success::{Success, FAIL, OK};
use crate::yaml::{size_t, yaml_char_t};
use crate::{
    libc, PointerExt, YamlAliasEvent, YamlAliasToken, YamlAnchorToken,
    YamlAnyEncoding, YamlBreakT, YamlDocumentEndEvent,
    YamlDocumentStartEvent, YamlDocumentT, YamlEmitterStateT,
    YamlEmitterT, YamlEncodingT, YamlEventT, YamlMappingEndEvent,
    YamlMappingNode, YamlMappingStartEvent, YamlMappingStyleT,
    YamlMarkT, YamlNodeItemT, YamlNodePairT, YamlNodeT,
    YamlParserStateT, YamlParserT, YamlReadHandlerT, YamlScalarEvent,
    YamlScalarNode, YamlScalarStyleT, YamlScalarToken,
    YamlSequenceEndEvent, YamlSequenceNode, YamlSequenceStartEvent,
    YamlSequenceStyleT, YamlSimpleKeyT, YamlStreamEndEvent,
    YamlStreamStartEvent, YamlTagDirectiveT, YamlTagDirectiveToken,
    YamlTagToken, YamlTokenT, YamlVersionDirectiveT, YamlWriteHandlerT,
};
use core::mem::{size_of, MaybeUninit};
use core::ptr::{self, addr_of_mut};

const INPUT_RAW_BUFFER_SIZE: usize = 16384;
const INPUT_BUFFER_SIZE: usize = INPUT_RAW_BUFFER_SIZE * 3;
const OUTPUT_BUFFER_SIZE: usize = 16384;
const OUTPUT_RAW_BUFFER_SIZE: usize = OUTPUT_BUFFER_SIZE * 2 + 2;

/// Allocate memory using the system's `malloc` function.
///
/// This function is a thin wrapper around the system's `malloc` function,
/// used for memory allocation within the LibYML crate.
///
/// # Safety
///
/// - This function is unsafe because it directly calls the system's `malloc` function,
///   which can lead to undefined behaviour if misused.
/// - The caller must ensure that the requested size is valid and does not overflow.
/// - The caller is responsible for properly freeing the allocated memory using
///   the corresponding `yaml_free` function when it is no longer needed.
///
pub unsafe fn yaml_malloc(size: size_t) -> *mut libc::c_void {
    malloc(size)
}

/// Reallocate memory using the system's `realloc` function.
///
/// This function is a thin wrapper around the system's `realloc` function,
/// used for memory reallocation within the LibYML crate.
///
/// # Safety
///
/// - This function is unsafe because it directly calls the system's `realloc` function,
///   which can lead to undefined behaviour if misused.
/// - The caller must ensure that the provided `ptr` is either a valid pointer returned
///   by a previous call to `yaml_malloc` or `yaml_realloc`, or a null pointer.
/// - The caller must ensure that the requested size is valid and does not overflow.
/// - If `realloc` fails to reallocate the memory, it returns a null pointer, and the
///   original memory block pointed to by `ptr` is left unchanged.
/// - The caller is responsible for properly freeing the reallocated memory using
///   the corresponding `yaml_free` function when it is no longer needed.
///
pub unsafe fn yaml_realloc(
    ptr: *mut libc::c_void,
    size: size_t,
) -> *mut libc::c_void {
    if !ptr.is_null() {
        realloc(ptr, size)
    } else {
        malloc(size)
    }
}

/// Free memory allocated by `yaml_malloc` or `yaml_realloc`.
///
/// This function is a thin wrapper around the system's `free` function,
/// used for freeing memory within the LibYML crate.
///
/// # Safety
///
/// - This function is unsafe because it directly calls the system's `free` function,
///   which can lead to undefined behaviour if misused.
/// - The caller must ensure that the provided `ptr` is either a valid pointer returned
///   by a previous call to `yaml_malloc` or `yaml_realloc`, or a null pointer.
/// - If `ptr` is a null pointer, no operation is performed.
///
pub unsafe fn yaml_free(ptr: *mut libc::c_void) {
    if !ptr.is_null() {
        free(ptr);
    }
}

/// Duplicate a string using the system's `strdup` function.
///
/// This function is a thin wrapper around the system's `strdup` function,
/// used for string duplication within the LibYML crate.
///
/// # Safety
///
/// - This function is unsafe because it directly calls the system's `strdup` function,
///   which can lead to undefined behaviour if misused.
/// - The caller must ensure that the provided `str` is either a valid pointer to a
///   null-terminated string, or a null pointer.
/// - If `str` is a null pointer, this function returns a null pointer.
/// - The caller is responsible for properly freeing the duplicated string using
///   the corresponding `yaml_free` function when it is no longer needed.
///
pub unsafe fn yaml_strdup(str: *const yaml_char_t) -> *mut yaml_char_t {
    if str.is_null() {
        return ptr::null_mut::<yaml_char_t>();
    }
    strdup(str as *mut libc::c_char) as *mut yaml_char_t
}

/// Extend a string buffer by reallocating and copying the existing data.
///
/// This function is used to grow a string buffer when more space is needed.
///
/// # Safety
///
/// - This function is unsafe because it directly calls the system's `realloc` and
///   `memset` functions, which can lead to undefined behaviour if misused.
/// - The caller must ensure that `start`, `pointer`, and `end` are valid pointers
///   into the same allocated memory block.
/// - The caller must ensure that the memory block being extended is large enough
///   to accommodate the new size.
/// - The caller is responsible for properly freeing the extended memory block using
///   the corresponding `yaml_free` function when it is no longer needed.
///
pub unsafe fn yaml_string_extend(
    start: *mut *mut yaml_char_t,
    pointer: *mut *mut yaml_char_t,
    end: *mut *mut yaml_char_t,
) {
    let new_start: *mut yaml_char_t = yaml_realloc(
        *start as *mut libc::c_void,
        (((*end).c_offset_from(*start) as libc::c_long)
            .force_mul(2_i64)) as size_t,
    ) as *mut yaml_char_t;
    memset(
        new_start.wrapping_offset(
            (*end).c_offset_from(*start) as libc::c_long as isize
        ) as *mut libc::c_void,
        0,
        (*end).c_offset_from(*start) as libc::c_ulong,
    );
    *pointer =
        new_start
            .wrapping_offset((*pointer).c_offset_from(*start)
                as libc::c_long as isize);
    *end = new_start.wrapping_offset(
        (((*end).c_offset_from(*start) as libc::c_long)
            .force_mul(2_i64)) as isize,
    );
    *start = new_start;
}

/// Join two string buffers by copying data from one to the other.
///
/// This function is used to concatenate two string buffers.
///
/// # Safety
///
/// - This function is unsafe because it directly calls the system's `memcpy` function,
///   which can lead to undefined behaviour if misused.
/// - The caller must ensure that `a_start`, `a_pointer`, `a_end`, `b_start`, `b_pointer`,
///   and `b_end` are valid pointers into their respective allocated memory blocks.
/// - The caller must ensure that the memory blocks being joined are large enough to
///   accommodate the combined data.
/// - The caller is responsible for properly freeing the joined memory block using
///   the corresponding `yaml_free` function when it is no longer needed.
///
pub unsafe fn yaml_string_join(
    a_start: *mut *mut yaml_char_t,
    a_pointer: *mut *mut yaml_char_t,
    a_end: *mut *mut yaml_char_t,
    b_start: *mut *mut yaml_char_t,
    b_pointer: *mut *mut yaml_char_t,
    _b_end: *mut *mut yaml_char_t,
) {
    if *b_start == *b_pointer {
        return;
    }
    while (*a_end).c_offset_from(*a_pointer) as libc::c_long
        <= (*b_pointer).c_offset_from(*b_start) as libc::c_long
    {
        yaml_string_extend(a_start, a_pointer, a_end);
    }
    memcpy(
        *a_pointer as *mut libc::c_void,
        *b_start as *const libc::c_void,
        (*b_pointer).c_offset_from(*b_start) as libc::c_ulong,
    );
    *a_pointer = (*a_pointer)
        .wrapping_offset((*b_pointer).c_offset_from(*b_start)
            as libc::c_long as isize);
}

/// Extend a stack by reallocating and copying the existing data.
///
/// This function is used to grow a stack when more space is needed.
///
/// # Safety
///
/// - This function is unsafe because it directly calls the system's `realloc` function,
///   which can lead to undefined behaviour if misused.
/// - The caller must ensure that `start`, `top`, and `end` are valid pointers into the
///   same allocated memory block.
/// - The caller must ensure that the memory block being extended is large enough to
///   accommodate the new size.
/// - The caller is responsible for properly freeing the extended memory block using
///   the corresponding `yaml_free` function when it is no longer needed.
///
pub unsafe fn yaml_stack_extend(
    start: *mut *mut libc::c_void,
    top: *mut *mut libc::c_void,
    end: *mut *mut libc::c_void,
) {
    let new_start: *mut libc::c_void = yaml_realloc(
        *start,
        (((*end as *mut libc::c_char)
            .c_offset_from(*start as *mut libc::c_char)
            as libc::c_long)
            .force_mul(2_i64)) as size_t,
    );
    *top = (new_start as *mut libc::c_char).wrapping_offset(
        (*top as *mut libc::c_char)
            .c_offset_from(*start as *mut libc::c_char)
            as libc::c_long as isize,
    ) as *mut libc::c_void;
    *end = (new_start as *mut libc::c_char).wrapping_offset(
        (((*end as *mut libc::c_char)
            .c_offset_from(*start as *mut libc::c_char)
            as libc::c_long)
            .force_mul(2_i64)) as isize,
    ) as *mut libc::c_void;
    *start = new_start;
}

/// Extend a queue by reallocating and copying the existing data.
///
/// This function is used to grow a queue when more space is needed.
///
/// # Safety
///
/// - This function is unsafe because it directly calls the system's `realloc` and
///   `memmove` functions, which can lead to undefined behaviour if misused.
/// - The caller must ensure that `start`, `head`, `tail`, and `end` are valid pointers
///   into the same allocated memory block.
/// - The caller must ensure that the memory block being extended is large enough to
///   accommodate the new size.
/// - The caller is responsible for properly freeing the extended memory block using
///   the corresponding `yaml_free` function when it is no longer needed.
///
pub unsafe fn yaml_queue_extend(
    start: *mut *mut libc::c_void,
    head: *mut *mut libc::c_void,
    tail: *mut *mut libc::c_void,
    end: *mut *mut libc::c_void,
) {
    if *start == *head && *tail == *end {
        let new_start: *mut libc::c_void = yaml_realloc(
            *start,
            (((*end as *mut libc::c_char)
                .c_offset_from(*start as *mut libc::c_char)
                as libc::c_long)
                .force_mul(2_i64)) as size_t,
        );
        *head = (new_start as *mut libc::c_char).wrapping_offset(
            (*head as *mut libc::c_char)
                .c_offset_from(*start as *mut libc::c_char)
                as libc::c_long as isize,
        ) as *mut libc::c_void;
        *tail = (new_start as *mut libc::c_char).wrapping_offset(
            (*tail as *mut libc::c_char)
                .c_offset_from(*start as *mut libc::c_char)
                as libc::c_long as isize,
        ) as *mut libc::c_void;
        *end = (new_start as *mut libc::c_char).wrapping_offset(
            (((*end as *mut libc::c_char)
                .c_offset_from(*start as *mut libc::c_char)
                as libc::c_long)
                .force_mul(2_i64)) as isize,
        ) as *mut libc::c_void;
        *start = new_start;
    }
    if *tail == *end {
        if *head != *tail {
            memmove(
                *start,
                *head,
                (*tail as *mut libc::c_char)
                    .c_offset_from(*head as *mut libc::c_char)
                    as libc::c_ulong,
            );
        }
        *tail = (*start as *mut libc::c_char).wrapping_offset(
            (*tail as *mut libc::c_char)
                .c_offset_from(*head as *mut libc::c_char)
                as libc::c_long as isize,
        ) as *mut libc::c_void;
        *head = *start;
    }
}

/// Initialize a parser.
///
/// This function creates a new parser object. An application is responsible
/// for destroying the object using the yaml_parser_delete() function.
///
/// # Safety
///
/// - `parser` must be a valid, non-null pointer to an uninitialized `YamlParserT` struct.
/// - The `YamlParserT` struct must be properly aligned and have the expected memory layout.
/// - The caller is responsible for properly destroying the parser object using `yaml_parser_delete`.
///
pub unsafe fn yaml_parser_initialize(
    parser: *mut YamlParserT,
) -> Success {
    __assert!(!parser.is_null());
    memset(
        parser as *mut libc::c_void,
        0,
        size_of::<YamlParserT>() as libc::c_ulong,
    );
    BUFFER_INIT!((*parser).raw_buffer, INPUT_RAW_BUFFER_SIZE);
    BUFFER_INIT!((*parser).buffer, INPUT_BUFFER_SIZE);
    QUEUE_INIT!((*parser).tokens, YamlTokenT);
    STACK_INIT!((*parser).indents, libc::c_int);
    STACK_INIT!((*parser).simple_keys, YamlSimpleKeyT);
    STACK_INIT!((*parser).states, YamlParserStateT);
    STACK_INIT!((*parser).marks, YamlMarkT);
    STACK_INIT!((*parser).tag_directives, YamlTagDirectiveT);
    OK
}

/// Destroy a parser.
///
/// This function frees all memory associated with a parser object, including
/// any dynamically allocated buffers, tokens, and other data structures.
///
/// # Safety
///
/// - `parser` must be a valid, non-null pointer to a properly initialized `YamlParserT` struct.
/// - The `YamlParserT` struct and its associated data structures must have been properly initialized and their memory allocated correctly.
/// - The `YamlParserT` struct and its associated data structures must be properly aligned and have the expected memory layout.
/// - After calling this function, the `parser` pointer should be considered invalid and should not be used again.
///
pub unsafe fn yaml_parser_delete(parser: *mut YamlParserT) {
    __assert!(!parser.is_null());
    BUFFER_DEL!((*parser).raw_buffer);
    BUFFER_DEL!((*parser).buffer);
    while !QUEUE_EMPTY!((*parser).tokens) {
        yaml_token_delete(addr_of_mut!(DEQUEUE!((*parser).tokens)));
    }
    QUEUE_DEL!((*parser).tokens);
    STACK_DEL!((*parser).indents);
    STACK_DEL!((*parser).simple_keys);
    STACK_DEL!((*parser).states);
    STACK_DEL!((*parser).marks);
    while !STACK_EMPTY!((*parser).tag_directives) {
        let tag_directive = POP!((*parser).tag_directives);
        yaml_free(tag_directive.handle as *mut libc::c_void);
        yaml_free(tag_directive.prefix as *mut libc::c_void);
    }
    STACK_DEL!((*parser).tag_directives);
    memset(
        parser as *mut libc::c_void,
        0,
        size_of::<YamlParserT>() as libc::c_ulong,
    );
}

unsafe fn yaml_string_read_handler(
    data: *mut libc::c_void,
    buffer: *mut libc::c_uchar,
    mut size: size_t,
    size_read: *mut size_t,
) -> libc::c_int {
    let parser: *mut YamlParserT = data as *mut YamlParserT;
    if (*parser).input.string.current == (*parser).input.string.end {
        *size_read = 0_u64;
        return 1;
    }
    if size
        > (*parser)
            .input
            .string
            .end
            .c_offset_from((*parser).input.string.current)
            as size_t
    {
        size = (*parser)
            .input
            .string
            .end
            .c_offset_from((*parser).input.string.current)
            as size_t;
    }
    memcpy(
        buffer as *mut libc::c_void,
        (*parser).input.string.current as *const libc::c_void,
        size,
    );
    let fresh80 = addr_of_mut!((*parser).input.string.current);
    *fresh80 = (*fresh80).wrapping_offset(size as isize);
    *size_read = size;
    1
}

/// Set a string input.
///
/// This function sets the input source for the parser to a string buffer.
/// Note that the `input` pointer must be valid while the `parser` object
/// exists. The application is responsible for destroying `input` after
/// destroying the `parser`.
///
/// # Safety
///
/// - `parser` must be a valid, non-null pointer to a properly initialized `YamlParserT` struct.
/// - The `YamlParserT` struct must not have an input handler already set.
/// - `input` must be a valid, non-null pointer to a null-terminated string buffer.
/// - The `input` string buffer must remain valid and unmodified until the `parser` object is destroyed.
/// - The `YamlParserT` struct and its associated data structures must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_parser_set_input_string(
    parser: *mut YamlParserT,
    input: *const libc::c_uchar,
    size: size_t,
) {
    assert!(!parser.is_null());
    assert!((*parser).read_handler.is_none());
    assert!(!input.is_null());

    (*parser).read_handler = Some(yaml_string_read_handler);
    (*parser).read_handler_data = parser as *mut libc::c_void;
    (*parser).input.string.start = input;
    (*parser).input.string.current = input;
    (*parser).input.string.end = input.wrapping_offset(size as isize);
}

/// Set a generic input handler.
///
/// This function sets a custom input handler for the parser.
///
/// # Safety
///
/// - `parser` must be a valid, non-null pointer to a properly initialized `YamlParserT` struct.
/// - The `YamlParserT` struct must not have an input handler already set.
/// - `handler` must be a valid function pointer that follows the signature of `YamlReadHandlerT`.
/// - `data` must be a valid pointer that will be passed to the `handler` function.
/// - The `YamlParserT` struct and its associated data structures must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_parser_set_input(
    parser: *mut YamlParserT,
    handler: YamlReadHandlerT,
    data: *mut libc::c_void,
) {
    __assert!(!parser.is_null());
    __assert!(((*parser).read_handler).is_none());
    let fresh89 = addr_of_mut!((*parser).read_handler);
    *fresh89 = Some(handler);
    let fresh90 = addr_of_mut!((*parser).read_handler_data);
    *fresh90 = data;
}

/// Set the source encoding.
///
/// This function sets the expected encoding of the input source for the parser.
///
/// # Safety
///
/// - `parser` must be a valid, non-null pointer to a properly initialized `YamlParserT` struct.
/// - The `YamlParserT` struct must not have an encoding already set, or the encoding must be `YamlAnyEncoding`.
/// - The `YamlParserT` struct and its associated data structures must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_parser_set_encoding(
    parser: *mut YamlParserT,
    encoding: YamlEncodingT,
) {
    __assert!(!parser.is_null());
    __assert!((*parser).encoding == YamlAnyEncoding);
    (*parser).encoding = encoding;
}

/// Initialize an emitter.
///
/// This function creates a new emitter object. An application is responsible
/// for destroying the object using the yaml_emitter_delete() function.
///
/// # Safety
///
/// - `emitter` must be a valid, non-null pointer to an uninitialized `YamlEmitterT` struct.
/// - The `YamlEmitterT` struct must be properly aligned and have the expected memory layout.
/// - The caller is responsible for properly destroying the emitter object using `yaml_emitter_delete`.
///
pub unsafe fn yaml_emitter_initialize(
    emitter: *mut YamlEmitterT,
) -> Success {
    __assert!(!emitter.is_null());
    memset(
        emitter as *mut libc::c_void,
        0,
        size_of::<YamlEmitterT>() as libc::c_ulong,
    );
    BUFFER_INIT!((*emitter).buffer, OUTPUT_BUFFER_SIZE);
    BUFFER_INIT!((*emitter).raw_buffer, OUTPUT_RAW_BUFFER_SIZE);
    STACK_INIT!((*emitter).states, YamlEmitterStateT);
    QUEUE_INIT!((*emitter).events, YamlEventT);
    STACK_INIT!((*emitter).indents, libc::c_int);
    STACK_INIT!((*emitter).tag_directives, YamlTagDirectiveT);
    OK
}

/// Destroy an emitter.
///
/// This function frees all memory associated with an emitter object, including
/// any dynamically allocated buffers, events, and other data structures.
///
/// # Safety
///
/// - `emitter` must be a valid, non-null pointer to a properly initialized `YamlEmitterT` struct.
/// - The `YamlEmitterT` struct and its associated data structures must have been properly initialized and their memory allocated correctly.
/// - The `YamlEmitterT` struct and its associated data structures must be properly aligned and have the expected memory layout.
/// - After calling this function, the `emitter` pointer should be considered invalid and should not be used again.
///
pub unsafe fn yaml_emitter_delete(emitter: *mut YamlEmitterT) {
    __assert!(!emitter.is_null());
    BUFFER_DEL!((*emitter).buffer);
    BUFFER_DEL!((*emitter).raw_buffer);
    STACK_DEL!((*emitter).states);
    while !QUEUE_EMPTY!((*emitter).events) {
        yaml_event_delete(addr_of_mut!(DEQUEUE!((*emitter).events)));
    }
    QUEUE_DEL!((*emitter).events);
    STACK_DEL!((*emitter).indents);
    while !STACK_EMPTY!((*emitter).tag_directives) {
        let tag_directive = POP!((*emitter).tag_directives);
        yaml_free(tag_directive.handle as *mut libc::c_void);
        yaml_free(tag_directive.prefix as *mut libc::c_void);
    }
    STACK_DEL!((*emitter).tag_directives);
    yaml_free((*emitter).anchors as *mut libc::c_void);
    memset(
        emitter as *mut libc::c_void,
        0,
        size_of::<YamlEmitterT>() as libc::c_ulong,
    );
}

unsafe fn yaml_string_write_handler(
    data: *mut libc::c_void,
    buffer: *mut libc::c_uchar,
    size: size_t,
) -> libc::c_int {
    let emitter: *mut YamlEmitterT = data as *mut YamlEmitterT;
    if (*emitter)
        .output
        .string
        .size
        .wrapping_sub(*(*emitter).output.string.size_written)
        < size
    {
        memcpy(
            (*emitter).output.string.buffer.wrapping_offset(
                *(*emitter).output.string.size_written as isize,
            ) as *mut libc::c_void,
            buffer as *const libc::c_void,
            (*emitter)
                .output
                .string
                .size
                .wrapping_sub(*(*emitter).output.string.size_written),
        );
        *(*emitter).output.string.size_written =
            (*emitter).output.string.size;
        return 0;
    }
    memcpy(
        (*emitter).output.string.buffer.wrapping_offset(
            *(*emitter).output.string.size_written as isize,
        ) as *mut libc::c_void,
        buffer as *const libc::c_void,
        size,
    );
    let fresh153 =
        addr_of_mut!((*(*emitter).output.string.size_written));
    *fresh153 = (*fresh153).wrapping_add(size);
    1
}

/// Set a string output.
///
/// This function sets the output destination for the emitter to a string buffer.
/// The emitter will write the output characters to the `output` buffer of the
/// specified `size`. The emitter will set `size_written` to the number of written
/// bytes. If the buffer is smaller than required, the emitter produces the
/// YAML_write_ERROR error.
///
/// # Safety
///
/// - `emitter` must be a valid, non-null pointer to a properly initialized `YamlEmitterT` struct.
/// - The `YamlEmitterT` struct must not have an output handler already set.
/// - `output` must be a valid, non-null pointer to a writeable buffer of size `size`.
/// - `size_written` must be a valid, non-null pointer to a `size_t` variable.
/// - The `output` buffer must remain valid and unmodified until the emitter is destroyed or the output is reset.
/// - The `YamlEmitterT` struct and its associated data structures must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_emitter_set_output_string(
    emitter: *mut YamlEmitterT,
    output: *mut libc::c_uchar,
    size: size_t,
    size_written: *mut size_t,
) {
    assert!(!emitter.is_null());
    assert!((*emitter).write_handler.is_none());
    assert!(!output.is_null());

    (*emitter).write_handler = Some(yaml_string_write_handler);
    (*emitter).write_handler_data = emitter as *mut libc::c_void;
    (*emitter).output.string.buffer = output;
    (*emitter).output.string.size = size;
    *size_written = 0;
}

/// Set a generic output handler.
///
/// This function sets a custom output handler for the emitter.
///
/// # Safety
///
/// - `emitter` must be a valid, non-null pointer to a properly initialized `YamlEmitterT` struct.
/// - The `YamlEmitterT` struct must not have an output handler already set.
/// - `handler` must be a valid function pointer that follows the signature of `YamlWriteHandlerT`.
/// - `data` must be a valid pointer that will be passed to the `handler` function.
/// - The `YamlEmitterT` struct and its associated data structures must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_emitter_set_output(
    emitter: *mut YamlEmitterT,
    handler: YamlWriteHandlerT,
    data: *mut libc::c_void,
) {
    __assert!(!emitter.is_null());
    __assert!(((*emitter).write_handler).is_none());
    let fresh161 = addr_of_mut!((*emitter).write_handler);
    *fresh161 = Some(handler);
    let fresh162 = addr_of_mut!((*emitter).write_handler_data);
    *fresh162 = data;
}

/// Set the output encoding.
///
/// This function sets the encoding to be used for the output by the emitter.
///
/// # Safety
///
/// - `emitter` must be a valid, non-null pointer to a properly initialized `YamlEmitterT` struct.
/// - The `YamlEmitterT` struct must not have an encoding already set, or the encoding must be `YamlAnyEncoding`.
/// - The `YamlEmitterT` struct and its associated data structures must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_emitter_set_encoding(
    emitter: *mut YamlEmitterT,
    encoding: YamlEncodingT,
) {
    __assert!(!emitter.is_null());
    __assert!((*emitter).encoding == YamlAnyEncoding);
    (*emitter).encoding = encoding;
}

/// Set if the output should be in the "canonical" format as in the YAML
/// specification.
///
/// This function sets whether the emitter should produce output in the canonical
/// format, as defined by the YAML specification.
///
/// # Safety
///
/// - `emitter` must be a valid, non-null pointer to a properly initialized `YamlEmitterT` struct.
/// - The `YamlEmitterT` struct and its associated data structures must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_emitter_set_canonical(
    emitter: *mut YamlEmitterT,
    canonical: bool,
) {
    __assert!(!emitter.is_null());
    (*emitter).canonical = canonical;
}

/// Set the indentation increment.
///
/// This function sets the indentation increment to be used by the emitter when
/// emitting indented content.
///
/// # Safety
///
/// - `emitter` must be a valid, non-null pointer to a properly initialized `YamlEmitterT` struct.
/// - The `YamlEmitterT` struct and its associated data structures must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_emitter_set_indent(
    emitter: *mut YamlEmitterT,
    indent: libc::c_int,
) {
    __assert!(!emitter.is_null());
    (*emitter).best_indent =
        if 1 < indent && indent < 10 { indent } else { 2 };
}

/// Set the preferred line width. -1 means unlimited.
///
/// This function sets the preferred line width for the emitter's output.
/// A value of -1 means that the line width is unlimited.
///
/// # Safety
///
/// - `emitter` must be a valid, non-null pointer to a properly initialized `YamlEmitterT` struct.
/// - The `YamlEmitterT` struct and its associated data structures must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_emitter_set_width(
    emitter: *mut YamlEmitterT,
    width: libc::c_int,
) {
    __assert!(!emitter.is_null());
    (*emitter).best_width = if width >= 0 { width } else { -1 };
}

/// Set if unescaped non-ASCII characters are allowed.
///
/// This function sets whether the emitter should allow unescaped non-ASCII
/// characters in its output.
///
/// # Safety
///
/// - `emitter` must be a valid, non-null pointer to a properly initialized `YamlEmitterT` struct.
/// - The `YamlEmitterT` struct and its associated data structures must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_emitter_set_unicode(
    emitter: *mut YamlEmitterT,
    unicode: bool,
) {
    __assert!(!emitter.is_null());
    (*emitter).unicode = unicode;
}

/// Set the preferred line break.
///
/// This function sets the preferred line break character to be used by the emitter.
///
/// # Safety
///
/// - `emitter` must be a valid, non-null pointer to a properly initialized `YamlEmitterT` struct.
/// - The `YamlEmitterT` struct and its associated data structures must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_emitter_set_break(
    emitter: *mut YamlEmitterT,
    line_break: YamlBreakT,
) {
    __assert!(!emitter.is_null());
    (*emitter).line_break = line_break;
}

/// Free any memory allocated for a token object.
///
/// This function frees the dynamically allocated memory associated with a `YamlTokenT` struct,
/// such as strings for tag directives, aliases, anchors, tags, and scalar values.
///
/// # Safety
///
/// - `token` must be a valid, non-null pointer to a `YamlTokenT` struct.
/// - The `YamlTokenT` struct must have been properly initialized and its memory allocated correctly.
/// - The `YamlTokenT` struct must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_token_delete(token: *mut YamlTokenT) {
    __assert!(!token.is_null());
    match (*token).type_ {
        YamlTagDirectiveToken => {
            yaml_free(
                (*token).data.tag_directive.handle as *mut libc::c_void,
            );
            yaml_free(
                (*token).data.tag_directive.prefix as *mut libc::c_void,
            );
        }
        YamlAliasToken => {
            yaml_free((*token).data.alias.value as *mut libc::c_void);
        }
        YamlAnchorToken => {
            yaml_free((*token).data.anchor.value as *mut libc::c_void);
        }
        YamlTagToken => {
            yaml_free((*token).data.tag.handle as *mut libc::c_void);
            yaml_free((*token).data.tag.suffix as *mut libc::c_void);
        }
        YamlScalarToken => {
            yaml_free((*token).data.scalar.value as *mut libc::c_void);
        }
        _ => {}
    }
    memset(
        token as *mut libc::c_void,
        0,
        size_of::<YamlTokenT>() as libc::c_ulong,
    );
}

unsafe fn yaml_check_utf8(
    start: *const yaml_char_t,
    length: size_t,
) -> Success {
    let end: *const yaml_char_t =
        start.wrapping_offset(length as isize);
    let mut pointer: *const yaml_char_t = start;
    while pointer < end {
        let mut octet: libc::c_uchar;
        let mut value: libc::c_uint;
        let mut k: size_t;
        octet = *pointer;
        let width: libc::c_uint = if octet & 0x80 == 0 {
            1
        } else if octet & 0xE0 == 0xC0 {
            2
        } else if octet & 0xF0 == 0xE0 {
            3
        } else if octet & 0xF8 == 0xF0 {
            4
        } else {
            0
        } as libc::c_uint;
        value = if octet & 0x80 == 0 {
            octet & 0x7F
        } else if octet & 0xE0 == 0xC0 {
            octet & 0x1F
        } else if octet & 0xF0 == 0xE0 {
            octet & 0xF
        } else if octet & 0xF8 == 0xF0 {
            octet & 0x7
        } else {
            0
        } as libc::c_uint;
        if width == 0 {
            return FAIL;
        }
        if pointer.wrapping_offset(width as isize) > end {
            return FAIL;
        }
        k = 1_u64;
        while k < width as libc::c_ulong {
            octet = *pointer.wrapping_offset(k as isize);
            if octet & 0xC0 != 0x80 {
                return FAIL;
            }
            value =
                (value << 6).force_add((octet & 0x3F) as libc::c_uint);
            k = k.force_add(1);
        }
        if !(width == 1
            || width == 2 && value >= 0x80
            || width == 3 && value >= 0x800
            || width == 4 && value >= 0x10000)
        {
            return FAIL;
        }
        pointer = pointer.wrapping_offset(width as isize);
    }
    OK
}

/// Create the STREAM-START event.
///
/// This function initializes a `YamlEventT` struct with the type `YamlStreamStartEvent`.
/// It is used to signal the start of a YAML stream being emitted.
///
/// # Safety
///
/// - `event` must be a valid, non-null pointer to a `YamlEventT` struct that can be safely written to.
/// - The `YamlEventT` struct must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_stream_start_event_initialize(
    event: *mut YamlEventT,
    encoding: YamlEncodingT,
) -> Success {
    let mark = YamlMarkT {
        index: 0_u64,
        line: 0_u64,
        column: 0_u64,
    };
    __assert!(!event.is_null());
    memset(
        event as *mut libc::c_void,
        0,
        size_of::<YamlEventT>() as libc::c_ulong,
    );
    (*event).type_ = YamlStreamStartEvent;
    (*event).start_mark = mark;
    (*event).end_mark = mark;
    (*event).data.stream_start.encoding = encoding;
    OK
}

/// Create the STREAM-END event.
///
/// This function initializes a `YamlEventT` struct with the type `YamlStreamEndEvent`.
/// It is used to signal the end of a YAML stream being emitted.
///
/// # Safety
///
/// - `event` must be a valid, non-null pointer to a `YamlEventT` struct that can be safely written to.
/// - The `YamlEventT` struct must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_stream_end_event_initialize(
    event: *mut YamlEventT,
) -> Success {
    let mark = YamlMarkT {
        index: 0_u64,
        line: 0_u64,
        column: 0_u64,
    };
    __assert!(!event.is_null());
    memset(
        event as *mut libc::c_void,
        0,
        size_of::<YamlEventT>() as libc::c_ulong,
    );
    (*event).type_ = YamlStreamEndEvent;
    (*event).start_mark = mark;
    (*event).end_mark = mark;
    OK
}

/// Create the DOCUMENT-START event.
///
/// The `implicit` argument is considered as a stylistic parameter and may be
/// ignored by the emitter.
///
/// # Safety
///
/// - `event` must be a valid, non-null pointer to a `YamlEventT` struct that can be safely written to.
/// - `version_directive`, if not null, must point to a valid `YamlVersionDirectiveT` struct.
/// - `tag_directives_start` and `tag_directives_end` must be valid pointers to `YamlTagDirectiveT` structs, or both must be null.
/// - If `tag_directives_start` and `tag_directives_end` are not null, the range they define must contain valid `YamlTagDirectiveT` structs with non-null `handle` and `prefix` members, and the `handle` and `prefix` strings must be valid UTF-8.
/// - The `YamlEventT`, `YamlVersionDirectiveT`, and `YamlTagDirectiveT` structs must be properly aligned and have the expected memory layout.
/// - The caller is responsible for freeing any dynamically allocated memory associated with the event using `yaml_event_delete`.
///
pub unsafe fn yaml_document_start_event_initialize(
    event: *mut YamlEventT,
    version_directive: *mut YamlVersionDirectiveT,
    tag_directives_start: *mut YamlTagDirectiveT,
    tag_directives_end: *mut YamlTagDirectiveT,
    implicit: bool,
) -> Success {
    let current_block: u64;
    let mark = YamlMarkT {
        index: 0_u64,
        line: 0_u64,
        column: 0_u64,
    };
    let mut version_directive_copy: *mut YamlVersionDirectiveT =
        ptr::null_mut::<YamlVersionDirectiveT>();
    struct TagDirectivesCopy {
        start: *mut YamlTagDirectiveT,
        end: *mut YamlTagDirectiveT,
        top: *mut YamlTagDirectiveT,
    }
    let mut tag_directives_copy = TagDirectivesCopy {
        start: ptr::null_mut::<YamlTagDirectiveT>(),
        end: ptr::null_mut::<YamlTagDirectiveT>(),
        top: ptr::null_mut::<YamlTagDirectiveT>(),
    };
    let mut value = YamlTagDirectiveT {
        handle: ptr::null_mut::<yaml_char_t>(),
        prefix: ptr::null_mut::<yaml_char_t>(),
    };
    __assert!(!event.is_null());
    __assert!(
        !tag_directives_start.is_null()
            && !tag_directives_end.is_null()
            || tag_directives_start == tag_directives_end
    );
    if !version_directive.is_null() {
        version_directive_copy =
            yaml_malloc(
                size_of::<YamlVersionDirectiveT>() as libc::c_ulong
            ) as *mut YamlVersionDirectiveT;
        (*version_directive_copy).major = (*version_directive).major;
        (*version_directive_copy).minor = (*version_directive).minor;
    }
    if tag_directives_start != tag_directives_end {
        let mut tag_directive: *mut YamlTagDirectiveT;
        STACK_INIT!(tag_directives_copy, YamlTagDirectiveT);
        tag_directive = tag_directives_start;
        loop {
            if tag_directive == tag_directives_end {
                current_block = 16203760046146113240;
                break;
            }
            __assert!(!((*tag_directive).handle).is_null());
            __assert!(!((*tag_directive).prefix).is_null());
            if yaml_check_utf8(
                (*tag_directive).handle,
                strlen((*tag_directive).handle as *mut libc::c_char),
            )
            .fail
            {
                current_block = 14964981520188694172;
                break;
            }
            if yaml_check_utf8(
                (*tag_directive).prefix,
                strlen((*tag_directive).prefix as *mut libc::c_char),
            )
            .fail
            {
                current_block = 14964981520188694172;
                break;
            }
            value.handle = yaml_strdup((*tag_directive).handle);
            value.prefix = yaml_strdup((*tag_directive).prefix);
            if value.handle.is_null() || value.prefix.is_null() {
                current_block = 14964981520188694172;
                break;
            }
            PUSH!(tag_directives_copy, value);
            value.handle = ptr::null_mut::<yaml_char_t>();
            value.prefix = ptr::null_mut::<yaml_char_t>();
            tag_directive = tag_directive.wrapping_offset(1);
        }
    } else {
        current_block = 16203760046146113240;
    }
    if current_block != 14964981520188694172 {
        memset(
            event as *mut libc::c_void,
            0,
            size_of::<YamlEventT>() as libc::c_ulong,
        );
        (*event).type_ = YamlDocumentStartEvent;
        (*event).start_mark = mark;
        (*event).end_mark = mark;
        let fresh164 = addr_of_mut!(
            (*event).data.document_start.version_directive
        );
        *fresh164 = version_directive_copy;
        let fresh165 = addr_of_mut!(
            (*event).data.document_start.tag_directives.start
        );
        *fresh165 = tag_directives_copy.start;
        let fresh166 = addr_of_mut!(
            (*event).data.document_start.tag_directives.end
        );
        *fresh166 = tag_directives_copy.top;
        (*event).data.document_start.implicit = implicit;
        return OK;
    }
    yaml_free(version_directive_copy as *mut libc::c_void);
    while !STACK_EMPTY!(tag_directives_copy) {
        let value = POP!(tag_directives_copy);
        yaml_free(value.handle as *mut libc::c_void);
        yaml_free(value.prefix as *mut libc::c_void);
    }
    STACK_DEL!(tag_directives_copy);
    yaml_free(value.handle as *mut libc::c_void);
    yaml_free(value.prefix as *mut libc::c_void);
    FAIL
}

/// Create the DOCUMENT-END event.
///
/// The `implicit` argument is considered as a stylistic parameter and may be
/// ignored by the emitter.
///
/// # Safety
///
/// - `event` must be a valid, non-null pointer to a `YamlEventT` struct that can be safely written to.
/// - The `YamlEventT` struct must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_document_end_event_initialize(
    event: *mut YamlEventT,
    implicit: bool,
) -> Success {
    let mark = YamlMarkT {
        index: 0_u64,
        line: 0_u64,
        column: 0_u64,
    };
    __assert!(!event.is_null());
    memset(
        event as *mut libc::c_void,
        0,
        size_of::<YamlEventT>() as libc::c_ulong,
    );
    (*event).type_ = YamlDocumentEndEvent;
    (*event).start_mark = mark;
    (*event).end_mark = mark;
    (*event).data.document_end.implicit = implicit;
    OK
}

/// Create an ALIAS event.
///
/// # Safety
///
/// - `event` must be a valid, non-null pointer to a `YamlEventT` struct that can be safely written to.
/// - `anchor` must be a valid, non-null pointer to a null-terminated UTF-8 string.
/// - The `YamlEventT` struct must be properly aligned and have the expected memory layout.
/// - The caller is responsible for freeing any dynamically allocated memory associated with the event using `yaml_event_delete`.
///
pub unsafe fn yaml_alias_event_initialize(
    event: *mut YamlEventT,
    anchor: *const yaml_char_t,
) -> Success {
    let mark = YamlMarkT {
        index: 0_u64,
        line: 0_u64,
        column: 0_u64,
    };
    __assert!(!event.is_null());
    __assert!(!anchor.is_null());
    if yaml_check_utf8(anchor, strlen(anchor as *mut libc::c_char)).fail
    {
        return FAIL;
    }
    let anchor_copy: *mut yaml_char_t = yaml_strdup(anchor);
    if anchor_copy.is_null() {
        return FAIL;
    }
    memset(
        event as *mut libc::c_void,
        0,
        size_of::<YamlEventT>() as libc::c_ulong,
    );
    (*event).type_ = YamlAliasEvent;
    (*event).start_mark = mark;
    (*event).end_mark = mark;
    let fresh167 = addr_of_mut!((*event).data.alias.anchor);
    *fresh167 = anchor_copy;
    OK
}

/// Create a SCALAR event.
///
/// The `style` argument may be ignored by the emitter.
///
/// Either the `tag` attribute or one of the `plain_implicit` and
/// `quoted_implicit` flags must be set.
///
/// # Safety
///
/// - `event` must be a valid, non-null pointer to a `YamlEventT` struct that can be safely written to.
/// - `data.value` must be a valid, non-null pointer to a null-terminated UTF-8 string.
/// - `data.anchor`, if not null, must be a valid pointer to a null-terminated UTF-8 string.
/// - `data.tag`, if not null, must be a valid pointer to a null-terminated UTF-8 string.
/// - The `YamlEventT` struct must be properly aligned and have the expected memory layout.
/// - The caller is responsible for freeing any dynamically allocated memory associated with the event using `yaml_event_delete`.
///
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[repr(C)]
pub struct ScalarEventData<'a> {
    /// Anchor name or null.
    pub anchor: *const yaml_char_t,
    /// Tag or null.
    pub tag: *const yaml_char_t,
    /// Value.
    pub value: *const yaml_char_t,
    /// Value length.
    pub length: libc::c_int,
    /// Is the tag optional for the plain style?
    pub plain_implicit: bool,
    /// Is the tag optional for any non-plain style?
    pub quoted_implicit: bool,
    /// Scalar style.
    pub style: YamlScalarStyleT,
    /// Lifetime marker.
    pub _marker: core::marker::PhantomData<&'a ()>,
}

/// Create a SCALAR event.
///
/// The `style` argument may be ignored by the emitter.
///
/// Either the `tag` attribute or one of the `plain_implicit` and
/// `quoted_implicit` flags must be set.
///
/// # Safety
///
/// - `event` must be a valid, non-null pointer to a `YamlEventT` struct that can be safely written to.
/// - `value` must be a valid, non-null pointer to a null-terminated UTF-8 string.
/// - `anchor`, if not null, must be a valid pointer to a null-terminated UTF-8 string.
/// - `tag`, if not null, must be a valid pointer to a null-terminated UTF-8 string.
/// - The `YamlEventT` struct must be properly aligned and have the expected memory layout.
/// - The caller is responsible for freeing any dynamically allocated memory associated with the event using `yaml_event_delete`.
///
pub unsafe fn yaml_scalar_event_initialize(
    event: *mut YamlEventT,
    mut data: ScalarEventData<'_>,
) -> Success {
    let mut current_block: u64;
    let mark = YamlMarkT {
        index: 0_u64,
        line: 0_u64,
        column: 0_u64,
    };
    let mut anchor_copy: *mut yaml_char_t =
        ptr::null_mut::<yaml_char_t>();
    let mut tag_copy: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
    let mut value_copy: *mut yaml_char_t =
        ptr::null_mut::<yaml_char_t>();

    __assert!(!event.is_null());
    __assert!(!data.value.is_null());

    if !data.anchor.is_null() {
        if yaml_check_utf8(
            data.anchor,
            strlen(data.anchor as *mut libc::c_char),
        )
        .fail
        {
            current_block = 16285396129609901221;
        } else {
            anchor_copy = yaml_strdup(data.anchor);
            if anchor_copy.is_null() {
                current_block = 16285396129609901221;
            } else {
                current_block = 8515828400728868193;
            }
        }
    } else {
        current_block = 8515828400728868193;
    }

    if current_block == 8515828400728868193 {
        if !data.tag.is_null() {
            if yaml_check_utf8(
                data.tag,
                strlen(data.tag as *mut libc::c_char),
            )
            .fail
            {
                current_block = 16285396129609901221;
            } else {
                tag_copy = yaml_strdup(data.tag);
                if tag_copy.is_null() {
                    current_block = 16285396129609901221;
                } else {
                    current_block = 12800627514080957624;
                }
            }
        } else {
            current_block = 12800627514080957624;
        }

        if current_block != 16285396129609901221 {
            if data.length < 0 {
                data.length = strlen(data.value as *mut libc::c_char)
                    as libc::c_int;
            }

            if yaml_check_utf8(data.value, data.length as size_t).ok {
                value_copy =
                    yaml_malloc(data.length.force_add(1) as size_t)
                        as *mut yaml_char_t;
                memcpy(
                    value_copy as *mut libc::c_void,
                    data.value as *const libc::c_void,
                    data.length as libc::c_ulong,
                );
                *value_copy.wrapping_offset(data.length as isize) =
                    b'\0';
                memset(
                    event as *mut libc::c_void,
                    0,
                    size_of::<YamlEventT>() as libc::c_ulong,
                );
                (*event).type_ = YamlScalarEvent;
                (*event).start_mark = mark;
                (*event).end_mark = mark;
                let fresh168 =
                    addr_of_mut!((*event).data.scalar.anchor);
                *fresh168 = anchor_copy;
                let fresh169 = addr_of_mut!((*event).data.scalar.tag);
                *fresh169 = tag_copy;
                let fresh170 = addr_of_mut!((*event).data.scalar.value);
                *fresh170 = value_copy;
                (*event).data.scalar.length = data.length as size_t;
                (*event).data.scalar.plain_implicit =
                    data.plain_implicit;
                (*event).data.scalar.quoted_implicit =
                    data.quoted_implicit;
                (*event).data.scalar.style = data.style;
                return OK;
            }
        }
    }

    yaml_free(anchor_copy as *mut libc::c_void);
    yaml_free(tag_copy as *mut libc::c_void);
    yaml_free(value_copy as *mut libc::c_void);
    FAIL
}

/// Create a SEQUENCE-START event.
///
/// The `style` argument may be ignored by the emitter.
///
/// Either the `tag` attribute or the `implicit` flag must be set.
///
/// # Safety
///
/// - `event` must be a valid, non-null pointer to a `YamlEventT` struct that can be safely written to.
/// - `anchor`, if not null, must be a valid pointer to a null-terminated UTF-8 string.
/// - `tag`, if not null, must be a valid pointer to a null-terminated UTF-8 string.
/// - The `YamlEventT` struct must be properly aligned and have the expected memory layout.
/// - The caller is responsible for freeing any dynamically allocated memory associated with the event using `yaml_event_delete`.
///
pub unsafe fn yaml_sequence_start_event_initialize(
    event: *mut YamlEventT,
    anchor: *const yaml_char_t,
    tag: *const yaml_char_t,
    implicit: bool,
    style: YamlSequenceStyleT,
) -> Success {
    let mut current_block: u64;
    let mark = YamlMarkT {
        index: 0_u64,
        line: 0_u64,
        column: 0_u64,
    };
    let mut anchor_copy: *mut yaml_char_t =
        ptr::null_mut::<yaml_char_t>();
    let mut tag_copy: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
    __assert!(!event.is_null());
    if !anchor.is_null() {
        if yaml_check_utf8(anchor, strlen(anchor as *mut libc::c_char))
            .fail
        {
            current_block = 8817775685815971442;
        } else {
            anchor_copy = yaml_strdup(anchor);
            if anchor_copy.is_null() {
                current_block = 8817775685815971442;
            } else {
                current_block = 11006700562992250127;
            }
        }
    } else {
        current_block = 11006700562992250127;
    }
    if current_block == 11006700562992250127 {
        if !tag.is_null() {
            if yaml_check_utf8(tag, strlen(tag as *mut libc::c_char))
                .fail
            {
                current_block = 8817775685815971442;
            } else {
                tag_copy = yaml_strdup(tag);
                if tag_copy.is_null() {
                    current_block = 8817775685815971442;
                } else {
                    current_block = 7651349459974463963;
                }
            }
        } else {
            current_block = 7651349459974463963;
        }
        if current_block != 8817775685815971442 {
            memset(
                event as *mut libc::c_void,
                0,
                size_of::<YamlEventT>() as libc::c_ulong,
            );
            (*event).type_ = YamlSequenceStartEvent;
            (*event).start_mark = mark;
            (*event).end_mark = mark;
            let fresh171 =
                addr_of_mut!((*event).data.sequence_start.anchor);
            *fresh171 = anchor_copy;
            let fresh172 =
                addr_of_mut!((*event).data.sequence_start.tag);
            *fresh172 = tag_copy;
            (*event).data.sequence_start.implicit = implicit;
            (*event).data.sequence_start.style = style;
            return OK;
        }
    }
    yaml_free(anchor_copy as *mut libc::c_void);
    yaml_free(tag_copy as *mut libc::c_void);
    FAIL
}

/// Create a SEQUENCE-END event.
///
/// This function initializes a `YamlEventT` struct with the type `YamlSequenceEndEvent`.
/// It is used to signal the end of a sequence in the YAML document being emitted.
///
/// # Safety
///
/// - `event` must be a valid, non-null pointer to a `YamlEventT` struct that can be safely written to.
/// - The `YamlEventT` struct must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_sequence_end_event_initialize(
    event: *mut YamlEventT,
) -> Success {
    let mark = YamlMarkT {
        index: 0_u64,
        line: 0_u64,
        column: 0_u64,
    };
    __assert!(!event.is_null());
    memset(
        event as *mut libc::c_void,
        0,
        size_of::<YamlEventT>() as libc::c_ulong,
    );
    (*event).type_ = YamlSequenceEndEvent;
    (*event).start_mark = mark;
    (*event).end_mark = mark;
    OK
}

/// Create a MAPPING-START event.
///
/// This function initializes a `YamlEventT` struct with the type `YamlMappingStartEvent`.
/// It is used to signal the start of a mapping (key-value pairs) in the YAML document being emitted.
///
/// The `style` argument may be ignored by the emitter.
///
/// Either the `tag` attribute or the `implicit` flag must be set.
///
/// # Safety
///
/// - `event` must be a valid, non-null pointer to a `YamlEventT` struct that can be safely written to.
/// - `anchor`, if not null, must be a valid pointer to a null-terminated UTF-8 string.
/// - `tag`, if not null, must be a valid pointer to a null-terminated UTF-8 string.
/// - The `YamlEventT` struct must be properly aligned and have the expected memory layout.
/// - The caller is responsible for freeing any dynamically allocated memory associated with the event using `yaml_event_delete`.
///
pub unsafe fn yaml_mapping_start_event_initialize(
    event: *mut YamlEventT,
    anchor: *const yaml_char_t,
    tag: *const yaml_char_t,
    implicit: bool,
    style: YamlMappingStyleT,
) -> Success {
    let mut current_block: u64;
    let mark = YamlMarkT {
        index: 0_u64,
        line: 0_u64,
        column: 0_u64,
    };
    let mut anchor_copy: *mut yaml_char_t =
        ptr::null_mut::<yaml_char_t>();
    let mut tag_copy: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
    __assert!(!event.is_null());
    if !anchor.is_null() {
        if yaml_check_utf8(anchor, strlen(anchor as *mut libc::c_char))
            .fail
        {
            current_block = 14748279734549812740;
        } else {
            anchor_copy = yaml_strdup(anchor);
            if anchor_copy.is_null() {
                current_block = 14748279734549812740;
            } else {
                current_block = 11006700562992250127;
            }
        }
    } else {
        current_block = 11006700562992250127;
    }
    if current_block == 11006700562992250127 {
        if !tag.is_null() {
            if yaml_check_utf8(tag, strlen(tag as *mut libc::c_char))
                .fail
            {
                current_block = 14748279734549812740;
            } else {
                tag_copy = yaml_strdup(tag);
                if tag_copy.is_null() {
                    current_block = 14748279734549812740;
                } else {
                    current_block = 7651349459974463963;
                }
            }
        } else {
            current_block = 7651349459974463963;
        }
        if current_block != 14748279734549812740 {
            memset(
                event as *mut libc::c_void,
                0,
                size_of::<YamlEventT>() as libc::c_ulong,
            );
            (*event).type_ = YamlMappingStartEvent;
            (*event).start_mark = mark;
            (*event).end_mark = mark;
            let fresh173 =
                addr_of_mut!((*event).data.mapping_start.anchor);
            *fresh173 = anchor_copy;
            let fresh174 =
                addr_of_mut!((*event).data.mapping_start.tag);
            *fresh174 = tag_copy;
            (*event).data.mapping_start.implicit = implicit;
            (*event).data.mapping_start.style = style;
            return OK;
        }
    }
    yaml_free(anchor_copy as *mut libc::c_void);
    yaml_free(tag_copy as *mut libc::c_void);
    FAIL
}

/// Create a MAPPING-END event.
///
/// This function initializes a `YamlEventT` struct with the type `YamlMappingEndEvent`.
/// It is used to signal the end of a mapping (key-value pairs) in the YAML document being emitted.
///
/// # Safety
///
/// - `event` must be a valid, non-null pointer to a `YamlEventT` struct that can be safely written to.
/// - The `YamlEventT` struct must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_mapping_end_event_initialize(
    event: *mut YamlEventT,
) -> Success {
    let mark = YamlMarkT {
        index: 0_u64,
        line: 0_u64,
        column: 0_u64,
    };
    __assert!(!event.is_null());
    memset(
        event as *mut libc::c_void,
        0,
        size_of::<YamlEventT>() as libc::c_ulong,
    );
    (*event).type_ = YamlMappingEndEvent;
    (*event).start_mark = mark;
    (*event).end_mark = mark;
    OK
}

/// Free any memory allocated for an event object.
///
/// This function frees the dynamically allocated memory associated with a `YamlEventT` struct,
/// such as strings for anchors, tags, and scalar values.
///
/// # Safety
///
/// - `event` must be a valid, non-null pointer to a `YamlEventT` struct.
/// - The `YamlEventT` struct must have been properly initialized and its memory allocated correctly.
/// - The `YamlEventT` struct must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_event_delete(event: *mut YamlEventT) {
    let mut tag_directive: *mut YamlTagDirectiveT;
    __assert!(!event.is_null());
    match (*event).type_ {
        YamlDocumentStartEvent => {
            yaml_free(
                (*event).data.document_start.version_directive
                    as *mut libc::c_void,
            );
            tag_directive =
                (*event).data.document_start.tag_directives.start;
            while tag_directive
                != (*event).data.document_start.tag_directives.end
            {
                yaml_free((*tag_directive).handle as *mut libc::c_void);
                yaml_free((*tag_directive).prefix as *mut libc::c_void);
                tag_directive = tag_directive.wrapping_offset(1);
            }
            yaml_free(
                (*event).data.document_start.tag_directives.start
                    as *mut libc::c_void,
            );
        }
        YamlAliasEvent => {
            yaml_free((*event).data.alias.anchor as *mut libc::c_void);
        }
        YamlScalarEvent => {
            yaml_free((*event).data.scalar.anchor as *mut libc::c_void);
            yaml_free((*event).data.scalar.tag as *mut libc::c_void);
            yaml_free((*event).data.scalar.value as *mut libc::c_void);
        }
        YamlSequenceStartEvent => {
            yaml_free(
                (*event).data.sequence_start.anchor
                    as *mut libc::c_void,
            );
            yaml_free(
                (*event).data.sequence_start.tag as *mut libc::c_void,
            );
        }
        YamlMappingStartEvent => {
            yaml_free(
                (*event).data.mapping_start.anchor as *mut libc::c_void,
            );
            yaml_free(
                (*event).data.mapping_start.tag as *mut libc::c_void,
            );
        }
        _ => {}
    }
    memset(
        event as *mut libc::c_void,
        0,
        size_of::<YamlEventT>() as libc::c_ulong,
    );
}

/// Create a YAML document.
///
/// This function initializes a `YamlDocumentT` struct with the provided version directive,
/// tag directives, and implicit flags. It allocates memory for the document data and
/// copies the provided directives.
///
/// # Safety
///
/// - `document` must be a valid, non-null pointer to a `YamlDocumentT` struct that can be safely written to.
/// - `version_directive`, if not null, must point to a valid `YamlVersionDirectiveT` struct.
/// - `tag_directives_start` and `tag_directives_end` must be valid pointers to `YamlTagDirectiveT` structs, or both must be null.
/// - If `tag_directives_start` and `tag_directives_end` are not null, the range they define must contain valid `YamlTagDirectiveT` structs with non-null `handle` and `prefix` members, and the `handle` and `prefix` strings must be valid UTF-8.
/// - The `YamlDocumentT`, `YamlVersionDirectiveT`, and `YamlTagDirectiveT` structs must be properly aligned and have the expected memory layout.
/// - The caller is responsible for freeing the memory allocated for the document using `yaml_document_delete`.
///
pub unsafe fn yaml_document_initialize(
    document: *mut YamlDocumentT,
    version_directive: *mut YamlVersionDirectiveT,
    tag_directives_start: *mut YamlTagDirectiveT,
    tag_directives_end: *mut YamlTagDirectiveT,
    start_implicit: bool,
    end_implicit: bool,
) -> Success {
    let current_block: u64;
    struct Nodes {
        start: *mut YamlNodeT,
        end: *mut YamlNodeT,
        top: *mut YamlNodeT,
    }
    let mut nodes = Nodes {
        start: ptr::null_mut::<YamlNodeT>(),
        end: ptr::null_mut::<YamlNodeT>(),
        top: ptr::null_mut::<YamlNodeT>(),
    };
    let mut version_directive_copy: *mut YamlVersionDirectiveT =
        ptr::null_mut::<YamlVersionDirectiveT>();
    struct TagDirectivesCopy {
        start: *mut YamlTagDirectiveT,
        end: *mut YamlTagDirectiveT,
        top: *mut YamlTagDirectiveT,
    }
    let mut tag_directives_copy = TagDirectivesCopy {
        start: ptr::null_mut::<YamlTagDirectiveT>(),
        end: ptr::null_mut::<YamlTagDirectiveT>(),
        top: ptr::null_mut::<YamlTagDirectiveT>(),
    };
    let mut value = YamlTagDirectiveT {
        handle: ptr::null_mut::<yaml_char_t>(),
        prefix: ptr::null_mut::<yaml_char_t>(),
    };
    let mark = YamlMarkT {
        index: 0_u64,
        line: 0_u64,
        column: 0_u64,
    };
    __assert!(!document.is_null());
    __assert!(
        !tag_directives_start.is_null()
            && !tag_directives_end.is_null()
            || tag_directives_start == tag_directives_end
    );
    STACK_INIT!(nodes, YamlNodeT);
    if !version_directive.is_null() {
        version_directive_copy =
            yaml_malloc(
                size_of::<YamlVersionDirectiveT>() as libc::c_ulong
            ) as *mut YamlVersionDirectiveT;
        (*version_directive_copy).major = (*version_directive).major;
        (*version_directive_copy).minor = (*version_directive).minor;
    }
    if tag_directives_start != tag_directives_end {
        let mut tag_directive: *mut YamlTagDirectiveT;
        STACK_INIT!(tag_directives_copy, YamlTagDirectiveT);
        tag_directive = tag_directives_start;
        loop {
            if tag_directive == tag_directives_end {
                current_block = 14818589718467733107;
                break;
            }
            __assert!(!((*tag_directive).handle).is_null());
            __assert!(!((*tag_directive).prefix).is_null());
            if yaml_check_utf8(
                (*tag_directive).handle,
                strlen((*tag_directive).handle as *mut libc::c_char),
            )
            .fail
            {
                current_block = 8142820162064489797;
                break;
            }
            if yaml_check_utf8(
                (*tag_directive).prefix,
                strlen((*tag_directive).prefix as *mut libc::c_char),
            )
            .fail
            {
                current_block = 8142820162064489797;
                break;
            }
            value.handle = yaml_strdup((*tag_directive).handle);
            value.prefix = yaml_strdup((*tag_directive).prefix);
            if value.handle.is_null() || value.prefix.is_null() {
                current_block = 8142820162064489797;
                break;
            }
            PUSH!(tag_directives_copy, value);
            value.handle = ptr::null_mut::<yaml_char_t>();
            value.prefix = ptr::null_mut::<yaml_char_t>();
            tag_directive = tag_directive.wrapping_offset(1);
        }
    } else {
        current_block = 14818589718467733107;
    }
    if current_block != 8142820162064489797 {
        memset(
            document as *mut libc::c_void,
            0,
            size_of::<YamlDocumentT>() as libc::c_ulong,
        );
        let fresh176 = addr_of_mut!((*document).nodes.start);
        *fresh176 = nodes.start;
        let fresh177 = addr_of_mut!((*document).nodes.end);
        *fresh177 = nodes.end;
        let fresh178 = addr_of_mut!((*document).nodes.top);
        *fresh178 = nodes.start;
        let fresh179 = addr_of_mut!((*document).version_directive);
        *fresh179 = version_directive_copy;
        let fresh180 = addr_of_mut!((*document).tag_directives.start);
        *fresh180 = tag_directives_copy.start;
        let fresh181 = addr_of_mut!((*document).tag_directives.end);
        *fresh181 = tag_directives_copy.top;
        (*document).start_implicit = start_implicit;
        (*document).end_implicit = end_implicit;
        (*document).start_mark = mark;
        (*document).end_mark = mark;
        return OK;
    }
    STACK_DEL!(nodes);
    yaml_free(version_directive_copy as *mut libc::c_void);
    while !STACK_EMPTY!(tag_directives_copy) {
        let value = POP!(tag_directives_copy);
        yaml_free(value.handle as *mut libc::c_void);
        yaml_free(value.prefix as *mut libc::c_void);
    }
    STACK_DEL!(tag_directives_copy);
    yaml_free(value.handle as *mut libc::c_void);
    yaml_free(value.prefix as *mut libc::c_void);
    FAIL
}

/// Delete a YAML document and all its nodes.
///
/// This function frees the memory allocated for a `YamlDocumentT` struct and all its associated
/// nodes, including scalar values, sequences, and mappings.
///
/// # Safety
///
/// - `document` must be a valid, non-null pointer to a `YamlDocumentT` struct.
/// - The `YamlDocumentT` struct and its associated nodes must have been properly initialized and their memory allocated correctly.
/// - The `YamlDocumentT` struct and its associated nodes must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_document_delete(document: *mut YamlDocumentT) {
    let mut tag_directive: *mut YamlTagDirectiveT;
    __assert!(!document.is_null());
    while !STACK_EMPTY!((*document).nodes) {
        let mut node = POP!((*document).nodes);
        yaml_free(node.tag as *mut libc::c_void);
        match node.type_ {
            YamlScalarNode => {
                yaml_free(node.data.scalar.value as *mut libc::c_void);
            }
            YamlSequenceNode => {
                STACK_DEL!(node.data.sequence.items);
            }
            YamlMappingNode => {
                STACK_DEL!(node.data.mapping.pairs);
            }
            _ => {
                __assert!(false);
            }
        }
    }
    STACK_DEL!((*document).nodes);
    yaml_free((*document).version_directive as *mut libc::c_void);
    tag_directive = (*document).tag_directives.start;
    while tag_directive != (*document).tag_directives.end {
        yaml_free((*tag_directive).handle as *mut libc::c_void);
        yaml_free((*tag_directive).prefix as *mut libc::c_void);
        tag_directive = tag_directive.wrapping_offset(1);
    }
    yaml_free((*document).tag_directives.start as *mut libc::c_void);
    memset(
        document as *mut libc::c_void,
        0,
        size_of::<YamlDocumentT>() as libc::c_ulong,
    );
}

/// Get a node of a YAML document.
///
/// This function returns a pointer to the node at the specified `index` in the document's node
/// stack. The pointer returned by this function is valid until any of the functions modifying the
/// document are called.
///
/// Returns the node object or NULL if `index` is out of range.
///
/// # Safety
///
/// - `document` must be a valid, non-null pointer to a `YamlDocumentT` struct.
/// - `index` must be a valid index within the range of nodes in the `YamlDocumentT` struct.
/// - The `YamlDocumentT` struct and its associated nodes must be properly initialized and their memory allocated correctly.
/// - The `YamlDocumentT` struct and its associated nodes must be properly aligned and have the expected memory layout.
/// - The caller must not modify or free the returned pointer, as it is owned by the `YamlDocumentT` struct.
///
pub unsafe fn yaml_document_get_node(
    document: *mut YamlDocumentT,
    index: libc::c_int,
) -> *mut YamlNodeT {
    __assert!(!document.is_null());
    if index > 0
        && (*document).nodes.start.wrapping_offset(index as isize)
            <= (*document).nodes.top
    {
        return (*document)
            .nodes
            .start
            .wrapping_offset(index as isize)
            .wrapping_offset(-1_isize);
    }
    ptr::null_mut::<YamlNodeT>()
}

/// Get the root of a YAML document node.
///
/// This function returns a pointer to the root node of the YAML document. The root object is the
/// first object added to the document.
///
/// The pointer returned by this function is valid until any of the functions modifying the
/// document are called.
///
/// An empty document produced by the parser signifies the end of a YAML stream.
///
/// Returns the node object or NULL if the document is empty.
///
/// # Safety
///
/// - `document` must be a valid, non-null pointer to a `YamlDocumentT` struct.
/// - The `YamlDocumentT` struct and its associated nodes must be properly initialized and their memory allocated correctly.
/// - The `YamlDocumentT` struct and its associated nodes must be properly aligned and have the expected memory layout.
/// - The caller must not modify or free the returned pointer, as it is owned by the `YamlDocumentT` struct.
///
pub unsafe fn yaml_document_get_root_node(
    document: *mut YamlDocumentT,
) -> *mut YamlNodeT {
    __assert!(!document.is_null());
    if (*document).nodes.top != (*document).nodes.start {
        return (*document).nodes.start;
    }
    ptr::null_mut::<YamlNodeT>()
}

/// Create a SCALAR node and attach it to the document.
///
/// This function creates a new SCALAR node with the provided `tag`, `value`, and `style`, and
/// adds it to the document's node stack.
///
/// The `style` argument may be ignored by the emitter.
///
/// Returns the node id or 0 on error.
///
/// # Safety
///
/// - `document` must be a valid, non-null pointer to a `YamlDocumentT` struct.
/// - `value` must be a valid, non-null pointer to a null-terminated UTF-8 string.
/// - `tag`, if not null, must be a valid pointer to a null-terminated UTF-8 string.
/// - The `YamlDocumentT` struct and its associated nodes must be properly initialized and their memory allocated correctly.
/// - The `YamlDocumentT` struct and its associated nodes must be properly aligned and have the expected memory layout.
/// - The caller is responsible for freeing the memory allocated for the document using `yaml_document_delete`.
///
#[must_use]
pub unsafe fn yaml_document_add_scalar(
    document: *mut YamlDocumentT,
    mut tag: *const yaml_char_t,
    value: *const yaml_char_t,
    mut length: libc::c_int,
    style: YamlScalarStyleT,
) -> libc::c_int {
    let mark = YamlMarkT {
        index: 0_u64,
        line: 0_u64,
        column: 0_u64,
    };
    let mut tag_copy: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
    let mut value_copy: *mut yaml_char_t =
        ptr::null_mut::<yaml_char_t>();
    let mut node = MaybeUninit::<YamlNodeT>::uninit();
    let node = node.as_mut_ptr();
    __assert!(!document.is_null());
    __assert!(!value.is_null());
    if tag.is_null() {
        tag = b"tag:yaml.org,2002:str\0" as *const u8
            as *const libc::c_char as *mut yaml_char_t;
    }
    if yaml_check_utf8(tag, strlen(tag as *mut libc::c_char)).ok {
        tag_copy = yaml_strdup(tag);
        if !tag_copy.is_null() {
            if length < 0 {
                length =
                    strlen(value as *mut libc::c_char) as libc::c_int;
            }
            if yaml_check_utf8(value, length as size_t).ok {
                value_copy = yaml_malloc(length.force_add(1) as size_t)
                    as *mut yaml_char_t;
                memcpy(
                    value_copy as *mut libc::c_void,
                    value as *const libc::c_void,
                    length as libc::c_ulong,
                );
                *value_copy.wrapping_offset(length as isize) = b'\0';
                memset(
                    node as *mut libc::c_void,
                    0,
                    size_of::<YamlNodeT>() as libc::c_ulong,
                );
                (*node).type_ = YamlScalarNode;
                (*node).tag = tag_copy;
                (*node).start_mark = mark;
                (*node).end_mark = mark;
                (*node).data.scalar.value = value_copy;
                (*node).data.scalar.length = length as size_t;
                (*node).data.scalar.style = style;
                PUSH!((*document).nodes, *node);
                return (*document)
                    .nodes
                    .top
                    .c_offset_from((*document).nodes.start)
                    as libc::c_int;
            }
        }
    }
    yaml_free(tag_copy as *mut libc::c_void);
    yaml_free(value_copy as *mut libc::c_void);
    0
}

/// Create a SEQUENCE node and attach it to the document.
///
/// This function creates a new SEQUENCE node with the provided `tag` and `style`, and adds it to
/// the document's node stack.
///
/// The `style` argument may be ignored by the emitter.
///
/// Returns the node id or 0 on error.
///
/// # Safety
///
/// - `document` must be a valid, non-null pointer to a `YamlDocumentT` struct.
/// - `tag`, if not null, must be a valid pointer to a null-terminated UTF-8 string.
/// - The `YamlDocumentT` struct and its associated nodes must be properly initialized and their memory allocated correctly.
/// - The `YamlDocumentT` struct and its associated nodes must be properly aligned and have the expected memory layout.
/// - The caller is responsible for freeing the memory allocated for the document using `yaml_document_delete`.
///
#[must_use]
pub unsafe fn yaml_document_add_sequence(
    document: *mut YamlDocumentT,
    mut tag: *const yaml_char_t,
    style: YamlSequenceStyleT,
) -> libc::c_int {
    let mark = YamlMarkT {
        index: 0_u64,
        line: 0_u64,
        column: 0_u64,
    };
    let mut tag_copy: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
    struct Items {
        start: *mut YamlNodeItemT,
        end: *mut YamlNodeItemT,
        top: *mut YamlNodeItemT,
    }
    let mut items = Items {
        start: ptr::null_mut::<YamlNodeItemT>(),
        end: ptr::null_mut::<YamlNodeItemT>(),
        top: ptr::null_mut::<YamlNodeItemT>(),
    };
    let mut node = MaybeUninit::<YamlNodeT>::uninit();
    let node = node.as_mut_ptr();
    __assert!(!document.is_null());
    if tag.is_null() {
        tag = b"tag:yaml.org,2002:seq\0" as *const u8
            as *const libc::c_char as *mut yaml_char_t;
    }
    if yaml_check_utf8(tag, strlen(tag as *mut libc::c_char)).ok {
        tag_copy = yaml_strdup(tag);
        if !tag_copy.is_null() {
            STACK_INIT!(items, YamlNodeItemT);
            memset(
                node as *mut libc::c_void,
                0,
                size_of::<YamlNodeT>() as libc::c_ulong,
            );
            (*node).type_ = YamlSequenceNode;
            (*node).tag = tag_copy;
            (*node).start_mark = mark;
            (*node).end_mark = mark;
            (*node).data.sequence.items.start = items.start;
            (*node).data.sequence.items.end = items.end;
            (*node).data.sequence.items.top = items.start;
            (*node).data.sequence.style = style;
            PUSH!((*document).nodes, *node);
            return (*document)
                .nodes
                .top
                .c_offset_from((*document).nodes.start)
                as libc::c_int;
        }
    }
    STACK_DEL!(items);
    yaml_free(tag_copy as *mut libc::c_void);
    0
}

/// Create a MAPPING node and attach it to the document.
///
/// This function creates a new MAPPING node with the provided `tag` and `style`, and adds it to
/// the document's node stack.
///
/// The `style` argument may be ignored by the emitter.
///
/// Returns the node id or 0 on error.
///
/// # Safety
///
/// - `document` must be a valid, non-null pointer to a `YamlDocumentT` struct.
/// - `tag`, if not null, must be a valid pointer to a null-terminated UTF-8 string.
/// - The `YamlDocumentT` struct and its associated nodes must be properly initialized and their memory allocated correctly.
/// - The `YamlDocumentT` struct and its associated nodes must be properly aligned and have the expected memory layout.
/// - The caller is responsible for freeing the memory allocated for the document using `yaml_document_delete`.
///
#[must_use]
pub unsafe fn yaml_document_add_mapping(
    document: *mut YamlDocumentT,
    mut tag: *const yaml_char_t,
    style: YamlMappingStyleT,
) -> libc::c_int {
    let mark = YamlMarkT {
        index: 0_u64,
        line: 0_u64,
        column: 0_u64,
    };
    let mut tag_copy: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
    struct Pairs {
        start: *mut YamlNodePairT,
        end: *mut YamlNodePairT,
        top: *mut YamlNodePairT,
    }
    let mut pairs = Pairs {
        start: ptr::null_mut::<YamlNodePairT>(),
        end: ptr::null_mut::<YamlNodePairT>(),
        top: ptr::null_mut::<YamlNodePairT>(),
    };
    let mut node = MaybeUninit::<YamlNodeT>::uninit();
    let node = node.as_mut_ptr();
    __assert!(!document.is_null());
    if tag.is_null() {
        tag = b"tag:yaml.org,2002:map\0" as *const u8
            as *const libc::c_char as *mut yaml_char_t;
    }
    if yaml_check_utf8(tag, strlen(tag as *mut libc::c_char)).ok {
        tag_copy = yaml_strdup(tag);
        if !tag_copy.is_null() {
            STACK_INIT!(pairs, YamlNodePairT);
            memset(
                node as *mut libc::c_void,
                0,
                size_of::<YamlNodeT>() as libc::c_ulong,
            );
            (*node).type_ = YamlMappingNode;
            (*node).tag = tag_copy;
            (*node).start_mark = mark;
            (*node).end_mark = mark;
            (*node).data.mapping.pairs.start = pairs.start;
            (*node).data.mapping.pairs.end = pairs.end;
            (*node).data.mapping.pairs.top = pairs.start;
            (*node).data.mapping.style = style;
            PUSH!((*document).nodes, *node);
            return (*document)
                .nodes
                .top
                .c_offset_from((*document).nodes.start)
                as libc::c_int;
        }
    }
    STACK_DEL!(pairs);
    yaml_free(tag_copy as *mut libc::c_void);
    0
}

/// Add an item to a SEQUENCE node.
///
/// This function adds a node with the given `item` id to the sequence node with the given
/// `sequence` id in the document.
///
/// # Safety
///
/// - `document` must be a valid, non-null pointer to a `YamlDocumentT` struct.
/// - `sequence` must be a valid index within the range of nodes in the `YamlDocumentT` struct, and the node at that index must be a `YamlSequenceNode`.
/// - `item` must be a valid index within the range of nodes in the `YamlDocumentT` struct.
/// - The `YamlDocumentT` struct and its associated nodes must be properly initialized and their memory allocated correctly.
/// - The `YamlDocumentT` struct and its associated nodes must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_document_append_sequence_item(
    document: *mut YamlDocumentT,
    sequence: libc::c_int,
    item: libc::c_int,
) -> Success {
    __assert!(!document.is_null());
    __assert!(
        sequence > 0
            && ((*document).nodes.start)
                .wrapping_offset(sequence as isize)
                <= (*document).nodes.top
    );
    __assert!(
        (*((*document).nodes.start)
            .wrapping_offset((sequence - 1) as isize))
        .type_
            == YamlSequenceNode
    );
    __assert!(
        item > 0
            && ((*document).nodes.start).wrapping_offset(item as isize)
                <= (*document).nodes.top
    );
    PUSH!(
        (*((*document).nodes.start)
            .wrapping_offset((sequence - 1) as isize))
        .data
        .sequence
        .items,
        item
    );
    OK
}

/// Add a pair of a key and a value to a MAPPING node.
///
/// This function adds a key-value pair to the mapping node with the given `mapping` id in the
/// document. The `key` and `value` arguments are the ids of the nodes to be used as the key and
/// value, respectively.
///
/// # Safety
///
/// - `document` must be a valid, non-null pointer to a `YamlDocumentT` struct.
/// - `mapping` must be a valid index within the range of nodes in the `YamlDocumentT` struct, and the node at that index must be a `YamlMappingNode`.
/// - `key` and `value` must be valid indices within the range of nodes in the `YamlDocumentT` struct.
/// - The `YamlDocumentT` struct and its associated nodes must be properly initialized and their memory allocated correctly.
/// - The `YamlDocumentT` struct and its associated nodes must be properly aligned and have the expected memory layout.
///
pub unsafe fn yaml_document_append_mapping_pair(
    document: *mut YamlDocumentT,
    mapping: libc::c_int,
    key: libc::c_int,
    value: libc::c_int,
) -> Success {
    __assert!(!document.is_null());
    __assert!(
        mapping > 0
            && ((*document).nodes.start)
                .wrapping_offset(mapping as isize)
                <= (*document).nodes.top
    );
    __assert!(
        (*((*document).nodes.start)
            .wrapping_offset((mapping - 1) as isize))
        .type_
            == YamlMappingNode
    );
    __assert!(
        key > 0
            && ((*document).nodes.start).wrapping_offset(key as isize)
                <= (*document).nodes.top
    );
    __assert!(
        value > 0
            && ((*document).nodes.start)
                .wrapping_offset(value as isize)
                <= (*document).nodes.top
    );
    let pair = YamlNodePairT { key, value };
    PUSH!(
        (*((*document).nodes.start)
            .wrapping_offset((mapping - 1) as isize))
        .data
        .mapping
        .pairs,
        pair
    );
    OK
}