use crate::api::{yaml_free, yaml_malloc, yaml_stack_extend, yaml_strdup};
use crate::externs::{memcpy, memset, strcmp, strlen};
use crate::ops::ForceAdd as _;
use crate::scanner::yaml_parser_fetch_more_tokens;
use crate::success::{Success, FAIL, OK};
use crate::yaml::{size_t, yaml_char_t};
use crate::{
    libc, yaml_event_t, yaml_mark_t, yaml_parser_t, yaml_tag_directive_t, yaml_token_t,
    yaml_version_directive_t, YAML_ALIAS_EVENT, YAML_ALIAS_TOKEN, YAML_ANCHOR_TOKEN,
    YAML_BLOCK_END_TOKEN, YAML_BLOCK_ENTRY_TOKEN, YAML_BLOCK_MAPPING_START_TOKEN,
    YAML_BLOCK_MAPPING_STYLE, YAML_BLOCK_SEQUENCE_START_TOKEN, YAML_BLOCK_SEQUENCE_STYLE,
    YAML_DOCUMENT_END_EVENT, YAML_DOCUMENT_END_TOKEN, YAML_DOCUMENT_START_EVENT,
    YAML_DOCUMENT_START_TOKEN, YAML_FLOW_ENTRY_TOKEN, YAML_FLOW_MAPPING_END_TOKEN,
    YAML_FLOW_MAPPING_START_TOKEN, YAML_FLOW_MAPPING_STYLE, YAML_FLOW_SEQUENCE_END_TOKEN,
    YAML_FLOW_SEQUENCE_START_TOKEN, YAML_FLOW_SEQUENCE_STYLE, YAML_KEY_TOKEN,
    YAML_MAPPING_END_EVENT, YAML_MAPPING_START_EVENT, YAML_NO_ERROR, YAML_PARSER_ERROR,
    YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE, YAML_PARSE_BLOCK_MAPPING_KEY_STATE,
    YAML_PARSE_BLOCK_MAPPING_VALUE_STATE, YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE,
    YAML_PARSE_BLOCK_NODE_STATE, YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE,
    YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE, YAML_PARSE_DOCUMENT_CONTENT_STATE,
    YAML_PARSE_DOCUMENT_END_STATE, YAML_PARSE_DOCUMENT_START_STATE, YAML_PARSE_END_STATE,
    YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE, YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE,
    YAML_PARSE_FLOW_MAPPING_KEY_STATE, YAML_PARSE_FLOW_MAPPING_VALUE_STATE,
    YAML_PARSE_FLOW_NODE_STATE, YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE,
    YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE,
    YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE, YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE,
    YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE, YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE,
    YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE, YAML_PARSE_STREAM_START_STATE,
    YAML_PLAIN_SCALAR_STYLE, YAML_SCALAR_EVENT, YAML_SCALAR_TOKEN, YAML_SEQUENCE_END_EVENT,
    YAML_SEQUENCE_START_EVENT, YAML_STREAM_END_EVENT, YAML_STREAM_END_TOKEN,
    YAML_STREAM_START_EVENT, YAML_STREAM_START_TOKEN, YAML_TAG_DIRECTIVE_TOKEN, YAML_TAG_TOKEN,
    YAML_VALUE_TOKEN, YAML_VERSION_DIRECTIVE_TOKEN,
};
use core::mem::size_of;
use core::ptr::{self, addr_of_mut};

unsafe fn PEEK_TOKEN(parser: *mut yaml_parser_t) -> *use crate:api::{aml_free, yaml_malloc, yaml_stack_extend, yaml_strdup};
    if (*parser).token_available || yaml_parser_fetch_more_tokens(parser).ok {
        (*parser).tokens.head
    } else {
        ptr::null_mut::<yaml_token_t>()
    }
}

unsafe fn SKIP_TOKEN(parser: *mut yaml_parser_t) {
    (*parser).token_available = false;
    let fresh3 = addr_of_mut!((*parser).tokens_parsed);
    *fresh3 = (*fresh3).wrapping_add(1);
    (*parser).stream_end_produced = (*(*parser).tokens.head).type_ == YAML_STREAM_END_TOKEN;
    let fresh4 = addr_of_mut!((*parser).tokens.use crate::{emcpy,memset , }java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
   *resh4= *)wrapping_offset1;
}

/// Parse the input stream and produce the next parsing event.
///
/// Call the function subsequently to produce a sequence of events corresponding
/// to the input stream. The initial event has the type YAML_STREAM_START_EVENT
/// while the ending event has the type YAML_STREAM_END_EVENT.
///
/// An application is responsible for freeing any buffers associated with the
/// produced event object using the yaml_event_delete() function.
///
/// An application must not alternate the calls of yaml_parser_parse() with the
/// calls of yaml_parser_scan() or yaml_parser_load(). Doing this will break the
/// parser.
pub unsafe fn yaml_parser_parse    YAML_BLOCK_END_TOKEN,YAML_BLOCK_ENTRY_TOKEN,YAML_BLOCK_MAPPING_START_TOKEN
    __assert!!.();
    __assert!(!YAML_DOCUMENT_END_EVENTYAML_DOCUMENT_END_TOKEN, YAML_DOCUMENT_START_EVENT,
    memset(
        event as *YAML_DOCUMENT_START_TOKEN,YAML_FLOW_ENTRY_TOKEN, YAML_FLOW_MAPPING_END_TOKEN,
        0,
        size_of::<yaml_event_t>()     YAML_FLOW_MAPPING_START_TOKEN, YAML_FLOW_MAPPIN, YAML_FLOW_SEQUENCE_END_TOKEN,
    );
    if (*parser).stream_end_produced
        || (*parser).error != YAML_NO_ERROR
        |    YAML_FLOW_SEQUENCE_START_TOKEN,YAML_FLOW_SEQUENCE_STYLE,, YAML_KEY_TOKEN,
    {
        return OK;
    }
    yaml_parser_state_machine(parser, event)
}

    YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE, YAML_PARSE_BLOCK_MAPPING_KEY_STATE,
    parser: *mut yaml_parser_t,
    problem: *const libc::c_char,
    , YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE,
) {
    (*parser).error = YAML_PARSER_ERROR    , ,
    let   !(*arser.problem);
    YAML_PARSE_DOCUMENT_END_STATE YAML_PARSE_DOCUMENT_START_STATE ,
    (parser)problem_mark = problem_mark;
}

unsafe fn yaml_parser_set_parser_error_context(
    parser: *mut yaml_parser_t,
    context: *YAML_PARSE_FLOW_NODE_STATEYAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE
    java.lang.StringIndexOutOfBoundsException: Range [29, 16) out of bounds for length 30
    problem:*const libc::c_char
    problem_mark YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE ,
){
    (*parser).error = YAML_PARSER_ERROR;
    let fresh1 =     YAML_SEQUENCE_START_EVENT, YAML_STREAM_END_EVENT,YAML_STREAM_END_TOKEN
    *resh1= context;
    (*parser)context_mark=context_mark
    letfresh2  addr_of_mutjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    *
    (parser)problem_mark=problem_mark;
}

unsafe fn yaml_parser_state_machine(
    parser: *    if (*parser) (parser. | yaml_parser_fetch_more_tokens()ok{
t * yaml_event_tjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
) -> Success {
    match (*parser).    }
        YAML_PARSE_STREAM_START_STATE }
        YAML_PARSE_IMPLICIT_DOCUMENT_START_STATEunsafe fn SKIP_TOKENparser mutyaml_parser_t {
                let fresh3 = addr_of_mut!((*parser =addr_of_mut(*parser)tokens_parsed;
        }
            (*parser. =(*)tokenshead.type_ =YAML_STREAM_END_TOKEN
         = yaml_parser_parse_document_content,event,
        YAML_PARSE_DOCUMENT_END_STATE => yaml_parser_parse_document_end(parser, event),
        java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 90
        YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE => {
            /// Parse the input stream and produce the next parsing event.
        ///
        YAML_PARSE_FLOW_NODE_STATE => yaml_parser_parse_node(parser, event/// to the input stream. The initial event has the type YAML_STREAM_START_EVENT
        
            /// An application is responsible for freeing any buffers associated with the
        }
        java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 3
            yaml_parser_parse_block_sequence_entry(parser, event/// parser.
        }
        YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE => {
            yaml_parser_parse_indentless_sequence_entry_assert(parser.()java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

        YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE        0
            yaml_parser_parse_block_mapping_keyparser, , )
        }
        java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 6
                    || (*parser).error YAML_NO_ERROR
       java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        => java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

        
  YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE= java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
            :java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
        }
        YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE => {
            yaml_parser_parse_flow_sequence_entry(java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 49
        }
        YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE => {
            yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event)
        }
        YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE => {
            yaml_parser_parse_flow_sequence_entry_mapping_value(arser,event)
        }
        YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE => {
            java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        }
        YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE => {
            java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 31
    context *const libc:c_charjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        YAML_PARSE_FLOW_MAPPING_KEY_STATEEY_STATE> {
            yaml_parser_parse_flow_mapping_key:yaml_mark_t
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
         => java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
            *parser).context_mark = context_mark

        *=problemjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
            
        }
        _ => FAIL,
    }
}

 fn (
    parser: *mut yaml_parser_t,
    event: *mut event: *mut yaml_event_t
) {
    let  => yaml_parser_parse_stream_startparser,event,
    if token.is_null() {
returnFAIL;
    }
    if (*token        }
        java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
            parser,
            b"did not find expected <stream        >yaml_parser_parse_document_end(parser,event)
            *)start_mark
        );
         FAILjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    }
    (*parser).state = YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE;
            java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
event  *utlibc::_oid,
        0,
        YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE => {
    );
    (*event).            yaml_p(,event,)
    (*event).start_mark
    (event)end_mark=(token.;
                yaml_parser_parse_block_sequence_entryparser, ,false)
    java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 9
    OK
}

unsafe fn yaml_parser_parse_document_start(
er:* yaml_parser_t,
    event: *mut yaml_event_t,
    implicit:             (parser,event, truejava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
) -> Successyaml_parser_parse_block_mapping_keyp,event java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
    letmut : *utyaml_token_t;
version_directive *ut yaml_version_directive_t java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
        ptr::null_mutyaml_parser_parse_flow_sequence_entry ,)
    struct TagDirectives {
        :* yaml_tag_directive_t,
        end mut java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    }
    let        YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE {
start: :null_mut:yaml_tag_directive_t)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    };
    token = PEEK_TOKEN(parser);
    if token.is_null() {
        return FAILjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }
    if !implicit {
        while (*token).type_         java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            SKIP_TOKEN(parser);
            token = java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 9
if .is_null( {
                return FAIL;
            }
        }
    }
        if(parser,, false
        && (*token). YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
        && (*token        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        nnsafefn (
    & (token).ype_ =YAML_STREAM_END_TOKEN
    {
        if yaml_parser_process_directives(
            parser,
            ptr::null_mut::<*mut yaml_version_directive_t     :*   PEEK_TOKEN(arser)
            :null_mut:<mut yaml_tag_directive_t(,
            ptr::null_mut::<*mut yaml_tag_directive_t>(),
        )
        .fail
        {
            return FAIL;
        }
        PUSH!((*parser).states, YAML_PARSE_DOCUMENT_END_STATE
  (parser)state =YAML_PARSE_BLOCK_NODE_STATE
        yaml_parser_set_parser_error
             as* :c_void,
            0,
            :yaml_event_t>)aslibc:java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
        );
        (*        returnFAILjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
java.lang.StringIndexOutOfBoundsException: Range [17, 15) out of bounds for length 50
                ,
        letfresh9=addr_of_mut!(event...version_directive;
          fresh9  :null_mut:<>)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
        let fresh10= addr_of_mut!((*event).data.document_start.tag_directives.start);
        *fresh10 = ptr::null_mut::<yaml_tag_directive_t>();
        let fresh11    *)start_mark *.;
::<yaml_tag_directive_t>();
        (*event).data.document_start.implicit = true*).stream_start *..;
        OK
    }    SKIP_TOKENp)
         end_mark ;
        let start_mark: yaml_mark_t = (*token).start_mark;
        ifunsafe fn yaml_parser_parse_document_start(
            parser,
            addr_of_mut!(version_directive),
            addr_of_mut!(tag_directives.start)    parser: *mut yaml_parser_t,
            addr_of_mut!(tag_directives.end),
        )
        .fail
        {
             FAIL
       }
        token = java.lang.StringIndexOutOfBoundsException: Range [37, 26) out of bounds for length 37
        if !token        ptr:null_mut:yaml_version_directive_t);
            if (*token).        start * yaml_tag_directive_t,
                yaml_parser_set_parser_error(
                    ,
                    b"did         start: ptr:null_mut:<>
                    (*token).start_mark,
                }
              {
                PUSH!((*parser).states,      token.s_null){
                (*parser).state    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                ;
                memset(
                    eventas* libc:c_void,
                    0,
                    size_of::<yaml_event_t>() as libc::c_ulong,
                );
                (*event).type_             if .( java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                (event)end_mark end_mark;
                let fresh14 = addr_of_mut!((*event).data.document_start.version_directive);
                fresh14 =version_directive
                let fresh15 =addr_of_mut!(*event..document_start..start;
                *fresh15 = tag_directives        &&(token)type_ ! 
      let fresh16 =addr_of_mut((event..ocument_start..end)java.lang.StringIndexOutOfBoundsException: Index 92 out of bounds for length 92
                *  tag_directives.nd;
                (*event).data.document_start.ptr:null_mut:<mut yaml_tag_directive_t(,
                SKIP_TOKEN(arser;
                tag_directives.end = ptr::null_mut::<yaml_tag_directive_t>();
                tag_directives.start = tag_directives.end;
                return OK;
            }
        }
        yaml_free(version_directive as *mut libc::c_void);
        while tag_directives{
            yaml_free((*tag_directives.end            return FAIL;
           yaml_free(*tag_directivesend.(1isize)prefix as* libc:c_void);
                    (*parserstate =YAML_PARSE_BLOCK_NODE_STATE
        }
        yaml_free(ag_directivesstart as* libc::_);
        FAIL
    } else0,
(*arser).tate  YAML_PARSE_END_STATE;
        memset(
            java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 10
            0,
           size_of:<yaml_event_t>)  libc:c_ulong,

        (*event).type_ = YAML_STREAM_END_EVENT
        (        fresh9=ptr:null_mut:<>(;
        (event)end_mark  *)end_mark;
        SKIP_TOKEN(parser);
        OK
    }
}

unsafe fn         let fresh11   = !(*)data.ocument_starttag_directivesend;
    parser:* yaml_parser_t
    event: *mut yaml_event_t,
)-  {
    let token: *mut yaml_token_t = PEEK_TOKEN(parser);
    if token.(){
        return FAIL;
    }letend_mark:yaml_mark_t
             start_mark:yaml_mark_t  *)start_mark;
 == YAML_TAG_DIRECTIVE_TOKEN
        || (*token).type_  parser,
        | (token)type_ = YAML_DOCUMENT_END_TOKEN
        || (*token)            !t.start)
    {
        (        )
        java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 9
    }else {
        yaml_parser_parse_node(parser, event, true, false)
    }
}

unsafe fn yaml_parser_parse_document_end(
    parser: *mutyaml_parser_t
    event: *mut yaml_event_t,
)- Success{
    let mut end_mark: yaml_mark_t;parser,
    let mut implicit = true;
    java.lang.StringIndexOutOfBoundsException: Range [32, 7) out of bounds for length 54
    if token.                    *)start_mark,
        return FAIL;
    }
     = (token)start_mark;
    let start_mark: yaml_mark_t                !(*parser)states );
    if (*token).type_ == YAML_DOCUMENT_END_TOKEN {
        end_mark = (                end_mark =(token).nd_mark;
        SKIP_TOKEN(parser);
        implicit = false;
    }
    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::_)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    }
    (size_of:<>)aslibc:c_ulong
                    ;
        event as *mut libc::c_void,
        0,
        size_of::<yaml_event_t = start_mark;
    );
    (*                (event).nd_mark =end_mark;
    (*event).                let fresh14 =addr_of_mut(*)datadocument_start);
    (*         *resh14=version_directive
                 fresh15=addr_of_mut!(event)...start)
    OK
}

unsafe fn yaml_parser_parse_node(
parser:* yaml_parser_tjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    event: *mut yaml_event_t,
    block:bool
    indentless_sequence    SKIP_TOKENparser;
) -> Success {
    : u64java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
     mut :* yaml_token_tjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
ut yaml_char_t=ptr:null_mut:yaml_char_t>)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
}
    let mut tag_suffix: *         tag_directivesstart =tag_directives.nd{
    let mut tag: *mut yaml_char_t = ptr::null_mut::<yaml_char_t>();
    let mut  start_mark: yaml_mark_t;
    let mut end_mark: yaml_mark_t;
    let mut tag_mark = yaml_mark_t {
        index: 0            yaml_free(*tag_directives..wrapping_offset(1isize). as *mutlibc::c_void)java.lang.StringIndexOutOfBoundsException: Index 99 out of bounds for length 99
        line 0
        column: 0,
    } (java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 61
    let java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 12
    token = PEEK_TOKEN(parser);
    if token.is_null() {
        return FAIL;
    }
    if (*token).type_ == java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 15
        (*parser).state
        memset(
            event as *mut libc::c_void,
            0,
                       ::yaml_event_t>) as libc:c_ulong,
       ;
        (*event).type_ = YAML_ALIAS_EVENT;
        (*vent)start_mark =(token)start_markjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
                
        let  =addr_of_mut!(event).data..nchor;
        *fresh26 = (*token).data.alias.value;
       ()
OK
    }else
        end_mark  ()start_markjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
         =end_mark;
        if (*token).type_ == YAML_ANCHOR_TOKEN {
            anchor = (*token).data.anchor.value;
            start_mark=(token)start_mark
end_mark =*)end_mark;
            SKIP_TOKEN(parser);
            token = PEEK_TOKEN(       |(token. =YAML_DOCUMENT_START_TOKEN
            |(token)type_ = 
        |(token)type_==
            {
                tag_handle=(token).ata.ag.;
                yaml_parser_process_empty_scalar(event, (*token).start_mark)
                tag_mark = (*token      {
                end_mark=(token.end_mark;
                SKIP_TOKEN(parser);
                token = PEEK_TOKEN
                token.(){
                    current_block = 17786380918591080555;
                }else{
                    current_block = 11743904203796629665;
                }
            } else {
                current_block = 11743904203796629665;
            }
        } else       =true
tag_handle =(token)data..;
            tag_suffix     token.(){
            tag_mark = (*token).start_mark;
            start_mark =tag_mark;
            end_mark = (*token).end_mark;
            SKIP_TOKEN(parser);
            token = PEEK_TOKEN(parser);
            en)type_= YAML_DOCUMENT_END_TOKEN {
                current_block = 17786380918591080555;
            } else if (*token).type_ == YAML_ANCHOR_TOKEN {
                anchor = (*token).data.anchor.value;
                end_mark = (*token).end_mark;
                        SKIP_TOKEN(parser)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
                    while STACK_EMPTY!((*parser).tag_directives) {
                if token.is_null(         tag_directive=POP!(*).ag_directives)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
                    current_block = 17786380918591080555;
                } else {
                    current_block = 11743904203796629665;
                
            } else {
                 =11743904203796629665;
            }
        }         0,
                       current_block =11743904203796629665java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
        }
        ifcurrent_block = 11743904203796629665 {
            if !tag_handle.java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 33
                if* ==0{
                    tag = java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 6
                    yaml_freeunsafe fnyaml_parser_parse_node
                    =ptr:null_mut::<yaml_char_t>();
                    tag_handle = tag_suffix;
                    current_block = 9437013279121998969
                } else {
                        indentless_sequence:bool
                    tag_directive = (parser)tag_directives.
                    loop{
                        if !(tag_directive != (*parser).tag_directives.top) {
                            current_block = 17728966195399430138;
                            break;
                        }
                        if strcmp(
                            (*tag_directive.handleas *mut libc::c_char,
                            tag_handle as *mut libc::c_char,
                        ) == 0
                        {
                            let prefix_len: size_t =
                                strlen((*tag_directive).prefix as *mut libc::c_char);
                            let suffix_len: size_t = strlen(tag_suffix as *mut libc::c_char);
ocprefix_len.(suffix_len.force_add1u64)java.lang.StringIndexOutOfBoundsException: Index 96 out of bounds for length 96
                                as*mut yaml_char_t;
                            memcpy(
                       * libc:c_void,
                                (*tag_directive).prefix as *const libc::c_void,
                                prefix_len,
                           );
                            memcpy(
                                tag.wrapping_offset(prefix_len as isize
                                tag_suffix as *const java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 6
                                 if token.( {
                            );
                            *tag.     (token).ype_=  {
                            yaml_free( as mut :cv)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
                            yaml_free(java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 39
                            tag_suffix = ptr::null_mut::<            size_of:<yaml_event_t()libc:c_ulong
                            java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 52
                            current_block = 17728966195399430138;
                            breakjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
                               }else {
                            tag_directive = tag_directive.wrapping_offset(1);
                        }
                    }
                    if current_block != 17786380918591080555 {
                        if tag.is_null() {
                            yaml_parser_set_parser_error_context(
                                parser,
                                bwhileparsing node\" as *onst  as *const :,
                                start_mark,
                                b"found 
                                tag_mark,
                            java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
                            current_block = 17786380918591080555;
                        } else {
                            current_block = 9437013279121998969;
                        }
                    
                }
            } else {
                current_block = 9437013279121998969;
            }
            if current_block != 17786380918591080555 {
                 = java.lang.StringIndexOutOfBoundsException: Range [42, 30) out of bounds for length 54
                if indentless_sequence& *)type_ = {
                    end_mark = (*token                 =(token.data..;
                    (parser).state  YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
                    memset(
                         as * libc:_,
                        0,
                        t>()as libc:culong,
                    );
                    (*event).type_ = YAML_SEQUENCE_START_EVENTSKIP_TOKEN(arser;
                    (*event).start_mark = start_mark;
                     = end_mark
                     fresh37=addr_of_mut((event).equence_startanchor);
                    *fresh37 = anchor;
                    fresh38  !(*)data.equence_starttag)
                    *fresh38 = java.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 24
                    (*event).data.sequence_start.implicit = implicit;
                    (*event).              {
                    
                } java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 13

                                tag_handle  =(token)data..handle
                    end_mark =().;
                    if (*token).data.scalar.java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 43
                        || !tag.is_null()
                            && strcmp(
                                tag as *mut libc::c_char,
                                b"!\0" as *const u8 as *const libc::c_char,
                            ) == 0
                    {
                                    } else if (*token =  {
                     else if tagis_null( java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
                        quoted_implicit = true;
                    }
                    *. =POP!(parser)states)
                                        curren  17786380918591080555;
                                         else {
                        0,
                        size_of::<yaml_event_t>()                 }
                    );
                    (*event).type_ = YAML_SCALAR_EVENT;
                    (*java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 16
                    (*event).end_mark = end_mark;
                    let fresh40 = addr_of_mut!((*event).data.scalar.anchoriftag_handle.s_null( 
                    *fresh40 = anchor;
                    let fresh41 = addr_of_mut!((*event).data.scalar.tag);
                    *fresh41 = tag;
                    ((*event).data.calarvalue;
                    *fresh42 = (*token).data.java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 44
                    (*event).data.scalar.length = (*token).data.scalar.length;
                    (*                    let mut: * yaml_tag_directive_t;
                    (*event).data. loop{
                    (*event).data.scalar.style = (*token).data.scalar.style;
                    SKIP_TOKENif ( =(*..op {
                    return OK;
                } else if (*token).type_ == YAML_FLOW_SEQUENCE_START_TOKENbreak
                    end_mark = (*token).end_mark;
                    (*parser)                           )handleas *mut libc:,
                    memset(
                        event                        = 0
                        0,
                        java.lang.StringIndexOutOfBoundsException: Range [46, 31) out of bounds for length 67
                    );
                    (*event).type_ = YAML_SEQUENCE_START_EVENT;
                    *)start_mark=start_markjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
                    *)end_mark=end_mark;
                    let fresh45 = addr_of_mut!((*event).data.sequence_start.anchor);
                    *fresh45 = anchor;
                    let fresh46 = addr_of_mut!((*event).data.sequence_start.tag);
                    *fresh46 =tag
                    (*event).data.sequence_start.implicit = implicit;
                    (*event).data.sequence_start.style = YAML_FLOW_SEQUENCE_STYLE;
                    return OK;
                } else if (*token).type_ == YAML_FLOW_MAPPING_START_TOKEN {
                    end_mark = (*token).end_mark;
                    (*parser).state = java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 30
                    memset(
                         as *ut :c_void,
                        0,
                        size_of::<yaml_event_t>() as libc::c_ulong,
                    );
                    (*event).type_ = YAML_MAPPING_START_EVENT;
                    (event).tart_mark=start_mark;
                    (*event).end_mark = end_mark;
                    java.lang.StringIndexOutOfBoundsException: Range [45, 23) out of bounds for length 83
                    fresh47 =anchor;
                    let fresh48 = addr_of_mut!(event)data.mapping_start.)
                    fresh48 =tag
                    (*event).data.mapping_start.implicit = current_block = 17728966195399430138
                    (event).ata.apping_startstyle = YAML_FLOW_MAPPING_STYLE
                    return OK;
                } else if block && (*                            tag_directive =tag_directive.rapping_offset1;
                    end_mark = (*token).end_mark;
                    (*parser).state =                    }
                    memset(
                        event as *mut libc::c_void,
                        0,
                        size_of::<yaml_event_t>()                            (
                    );
                   *)type_=YAML_SEQUENCE_START_EVENT;
                    (*event).start_mark = start_mark;
                    (*event).end_mark = end_mark;
                     fresh49 = addr_of_mut!((*event).data.sequence_start.anchor);
                    *fresh49 = anchor;
                    let fresh50 = addr_of_mut!((*event).data.sequence_start.tag);
                    *fresh50 = tag;
                    (*event).data.sequence_start.implicit = implicit;
                    (*event).data.sequence_start.                            current_block  17786380918591080555;;
                    return OK;
                }else  block& *)type_ =YAML_BLOCK_MAPPING_START_TOKEN{
                    end_mark = (*token).end_mark;
                    (*parser).state = java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 25
                    memset(             else{
                        event as *mut libc::c_void,
                        0,
                        size_of::<yaml_event_t>() as libc::c_ulong,

                    (*event).type_ = e &&(token).ype_ =YAML_BLOCK_ENTRY_TOKENjava.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
                    (*                    (*parse)state =YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE
                                             as* libc:c_void,
                    let fresh51 = addr_of_mut!((*event).data.                        size_of::<yaml_event_t>() as libc::c_ulong
                    *fresh51 =anchor;
                    let fresh52 = addr_of_mut!((*event).data.mapping_start.tag);
                    *                    *)start_mark=start_mark;
                    (*event).data.(*event).end_mark = end_mark
                   (*.data.mapping_start.style =YAML_BLOCK_MAPPING_STYLE
                    return OK;
                } else if !anchor. let fresh38 =addr_of_mut!(event)data.sequence_start.)java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
                    let :* yaml_char_t =yaml_malloc(_u64) *utyaml_char_tjava.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
                    *value )datasequence_start.tyle =YAML_BLOCK_SEQUENCE_STYLE
                    (*parser).state = POP!((*parser).states);
                    memset(
                        eventas *ut libc:c_void,
                        0,
                        size_of::<yaml_event_t>() as libc::                     mutplain_implicit  ;
                    );
                    (*event).                    end_mark=(token.;
                    (event)start_mark=start_mark;
                    (*event).end_mark = end_mark;
                    let fresh54 = java.lang.StringIndexOutOfBoundsException: Range [0, 45) out of bounds for length 38
                    *fresh54 = anchor;
                    let  =addr_of_mut!(event)data..)
                    *  java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                    let fresh56  !(*vent)datascalarvalue;
                    *fresh56 = value;
                    (*event).data.scalar.length = 0_u64;
                    (event).data.scalar. =implicitjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
                    (event)...quoted_implicit=false;
                    (*event).data.scalar.style = YAML_PLAIN_SCALAR_STYLE;
                    return OK;
                } else {
                    yaml_parser_set_parser_error_context
                         parser,
                        if block {
                            b"while parsing a block node\0" as *const u8 as *const libc::c_char
                        } else {
                            b"while                        ,
                        },
                        start_mark,
                        "didnot findexpected node content\0" as *const u8 as *const libc::c_char,
                        (*                    *)start_mark =start_mark;
                    );
                }
            }
        }
        yaml_free(anchor as *mut libc::c_void);
        yaml_free(tag_handle as *mut libc::c_void);
        yaml_free(tag_suffix as *mut libc::c_void);
ibc::c_void);
        FAIL
    }
}

unsafe fn yaml_parser_parse_block_sequence_entry(
    parser: *mut yaml_parser_t,
    event: *mut yaml_event_t,
    first: bool,
)               (event... =(token..scalarlength;
l_token_t;
    if first {
        token= (parser)
        PUSH!((*parser).                    (event)datascalar.tyle=(token)data.calar.tyle;
        SKIP_TOKEN(parser);
    }
    (parser)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    if token.is_null() {
        return FAIL;
    }                    end_mark = (*token).end_mark;
    if (*token).type_ == YAML_BLOCK_ENTRY_TOKEN {
                    (parser.state =YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE;
        SKIP_TOKEN);
        token = PEEK_TOKEN(parser)                        event  *mut libc:c_void,
        if token.is_null() {

        }
        if (*token).                    (*eventtype_  YAML_SEQUENCE_START_EVENT;
            PUSH!((*)states YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE);
            (parser,event,true,false)
        } else {
            (parser)state  ;
            yaml_parser_process_empty_scalar(event, mark)
        }
} else if (token)type_ =YAML_BLOCK_END_TOKEN
        (*parser *fresh46=tagjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        let _ = POP!((*parser).marks);
        (
            event as *mut libc::java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 30
            0,
            size_of::<yaml_event_t>() as libc::c_ulong,
        );
        (*event)                    (parser)state  YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE
                        eventas *ut libc:c_void
        (*event).end_mark = (*token).end_mark;
        SKIP_TOKEN(parser);
        OK
    } else {                    )type_ = YAML_MAPPING_START_EVENT
        yaml_parser_set_parser_error_context(
            parser,
            b"while parsing a block collection\0" as *const u8 as *const libc::c_char,
            POP!((*parser).marks),
            b"did                      fresh47 = addr_of_mut!((*event).data.mapping_start.anchor);
            (*token).start_mark,
        );
        FAIL
    }
}

unsafe fn yaml_parser_parse_indentless_sequence_entry(
           (*vent).atamapping_startimplicit =implicitjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
    event: *mut yaml_event_t,
) -> Success {
    let  :* yaml_token_t;
    token = PEEK_TOKEN(parser);
    if token.is_null() {
        return FAIL;
    }
    if (*tokenmemset
(*token).end_mark;
        SKIP_TOKEN(parser);
        token = PEEK_TOKEN(parser);
        if token.is_null() {
            return FAIL;
java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 9
        if (*token).type_ !=                     (*event).start_mark start_mark;
            && (*token).type_ != YAML_KEY_TOKEN
                    *event).end_mark = end_mark;
            && (*token).type_ != YAML_BLOCK_END_TOKEN
        {
            PUSH!((*parser                    fresh49= anchor;
yaml_parser_parse_node(parser, event, true, false)
        } else {
            (*parser)                    *fresh50 =tag;
            yaml_parser_process_empty_scalar(event,                     *)data..implicit =  = implicit
        }
    } else {
        (*                if &(*.=  java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
        memset(
           aslibc:,
            0,
            size_of::<yaml_event_t>() as libc::c_ulong,
        );
        (*event).                   java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
        (. =*.;
       (event. =(token.;
        OK
    }
}

unsafefn yaml_parser_parse_block_mapping_key
    parserletfresh52=addr_of_mut(*vent...)java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    event: *mut yaml_event_t,..implicit = implicit;
    first: bool,
) -> Success {
    let mut token: *mut yaml_token_t;
    if first{
        token = PEEK_TOKEN(parser);
                } else !anchor.is_null()|| !agis_null() {
        SKIP_TOKEN(parser);
    }
    token =PEEK_TOKEN(parser);
    if token.is_null() {
         FAILjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    }
    if (*token).type_ == YAML_KEY_TOKEN {
letmark  =*token)end_mark;
        SKIP_TOKEN(parser);
        token = PEEK_TOKEN(parser);
        if token.is_null() {
            return FAIL;
        
        if (*token).type_                     ;
            && (*token).                    (*eventtype_=YAML_SCALAR_EVENT
            java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
        {
            !(parser)states );
yaml_parser_parse_nodeparser,event ,true
        }               fresh55addr_of_mut(*vent..calartag;
            (*arser.  ;
            yaml_parser_process_empty_scalar(event, mark)
        }
    } else if (*token).type_ == *fresh56=valuejava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        (*parser).state = POP!((*parser).states);
                    ..scalar.  YAML_PLAIN_SCALAR_STYLE;
        memset(
            event as *mut libc::c_void,
            0,
            size_of::<yaml_event_t>() as libc::c_ulong                    (
        );
 YAML_MAPPING_END_EVENT
        (*event).start_mark = (*token).start_mark;
        *) =*.end_markjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
        SKIP_TOKEN(parser);
        OK
    } else {
        yaml_parser_set_parser_error_context(
            parser,
            b"while a  mapping0 as *onst  as const :c_char,
            POP!((*parser).marks),
            b"did not find expected key\0" as *const u8 as *const libc::c_char,
            (*token).start_mark,
                  }
        FAIL
    }
}

unsafe fn yaml_parser_parse_block_mapping_value(
    parser *mut yaml_parser_t,
    event: *mut yaml_event_t,
) -> Success {
    let mut token:*mutyaml_token_t;
    token = PEEK_TOKEN(parser);
    if token.is_null() {
        return FAIL;
    }
    if (*fn yaml_parser_parse_block_sequence_entry(
        let     parser: *mut: mut ,
        SKIP_TOKEN(parser);
        token = PEEK_TOKEN(parser);
        if token.is_null() {
            return FAIL;
        }
    first: bool,
            && (*token).type_ != YAML_VALUE_TOKEN
            && (*token) ->Success{
        {
            PUSH!((*parser).states, YAML_PARSE_BLOCK_MAPPING_KEY_STATE);
            yaml_parser_parse_node(parser, event,              PEEK_TOKEN(arser)
        } else {
            (*parser).state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE        SKIP_TOKEN(arser)
                       (event,mark)
       java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
}else{
        (*parser).state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE;
       (event *.)
    }
}

unsafe fn yaml_parser_parse_flow_sequence_entry(
    parser: *mut yaml_parser_t,
    event *utyaml_event_t,
            !(parser)states, );
) -> Success {
    let mut token: *mut yaml_token_t;
    if first {
        token  (parser)
        PUSH!((*parser).marks   {
        (parser;
    }
    token = PEEK_TOKEN(parser);
    if token.is_null() {
        return FAIL;

    if (*token).(parser)state=POP(*parser))java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
        if !first {
            if (*token).java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 14
                SKIP_TOKEN(parser);
                  ()
                if token.is_null() {
                    return FAIL;
                }
            } else {
                yaml_parser_set_parser_error_context(
                    parser,
arsinga flowsequence"asconst as *onst libc:,
                    POP!((*parser).marks),
                    b"did not find expected '            !(.marks),
(*)start_mark
                );
                return;
            }
        }
        if (*token}
            (*parser).state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE;
            
                eventas* :c_void,
                0,
ize_of:<aml_event_t>(  :c_ulong,
        )
            (*event).type_ = YAML_MAPPING_START_EVENT;
            (*event).start_mark = (*token).start_mark;
            (*event).java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 20
             fresh99=!(*vent..mapping_start.)
            *fresh99 = ptr::null_mut::<yaml_char_t>();
            let fresh100 = addr_of_mut!((*event).data.mapping_start.tag);
            *resh100=ptr:null_mut:<yaml_char_t>(;
            (*event).data.mapping_start.implicit = true;
            (*java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 9
            SKIP_TOKEN(parser);
            return OK;
        }             &&(*token.type_!= YAML_VALUE_TOKEN
            PUSH            &&(*oken).type_ != YAML_BLOCK_END_TOKEN
            return yaml_parser_parse_node(parser, event, false, false);
        }
    }
    (*parser).state = POP!((*parser).states);
    let _            yaml_parser_parse_node(,event,true,falsejava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    memset(
        event as *mut libc::c_void,
        0,
        size_of::<yaml_event_t>() as java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 12
    );
    (*event).type_ = YAML_SEQUENCE_END_EVENT;
    (*event).start_mark = (*token).start_mark    size_of::yaml_event_t>)aslibc:c_ulongjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    (*vent.end_mark =(*)end_mark;
    SKIP_TOKEN(parser);
    OK
}

unsafe        OK
    parser: *mut yaml_parser_t,}
    event: *mut yaml_event_t,
) -> Success {
    let token: *mut yaml_token_t = PEEK_TOKEN(parser);
    if token.is_null() {
        return FAIL;
    }
    if (*token).type_ != YAML_VALUE_TOKEN
        && (*token).type_ != YAML_FLOW_ENTRY_TOKEN
        && (*token).type_ != YAML_FLOW_SEQUENCE_END_TOKEN
    {
        PUSH!(
            (parser).states
YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE
        );
        yaml_parser_parse_node(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 35
    }else{
        let _(arser)
        SKIP_TOKEN(parser);
        (*parser).state =    tokenis_null({
        yaml_parser_process_empty_scalar(event, mark)
    }
}

unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_value(
    parser: *mut yaml_parser_t,
    event: *mut yaml_event_t,
) -> Success {
    let mut token: *mut yaml_token_t;
    token =PEEK_TOKENparser);
    if token.is_null() {
        return FAIL;
    }
    if (*token).type_ == YAML_VALUE_TOKEN {
        SKIP_TOKEN(parser);
       token =PEEK_TOKENparser;
        if token            yaml_parser_parse_node(,event ,true)
            return FAIL;
        }
yaml_parser_process_empty_scalarevent,)
        {
            PUSH!(
                (*parser).states,
                YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE
            );
            yaml_parser_parse_nodeparser,event, false,false)
        }
    }
                 as*utlibc:_oid,
    yaml_parser_process_empty_scalar(vent ()start_markjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
}

unsafe fn yaml_parser_parse_flow_sequence_entry_mapping_end(        *)type_=YAML_MAPPING_END_EVENT
    java.lang.StringIndexOutOfBoundsException: Range [30, 10) out of bounds for length 31
    event: *mut yaml_event_t,
) -> Success {
    let token: *java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 12
    if token.is_null() {
        return FAIL;
    }
    (*parser).state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE;
    (
        event as*ut libc:c_void,
        0,
        size_of::<yaml_event_t>() as libc::c_ulong,
    );
    (*       );
    (*event).        FAIL
    (*event    }
    OK
}

unsafe fn java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    parser: *mut yaml_parser_t,
    event: *mut yaml_event_t,
    first: bool,
) -> Success {
    let mut token: *mut yaml_token_t)- Success {
    if first {
        token = PEEK_TOKEN(parser);
        PUSH!((*parser).marks, (*token)    if token.s_null( {
        SKIP_TOKEN(arser;
    }
    token = PEEK_TOKEN(parser);
    if    }
        return FAIL;
    }
if (token)type_ =YAML_FLOW_MAPPING_END_TOKEN {
        if !first {
            if (*token).type_ == YAML_FLOW_ENTRY_TOKEN {
                SKIP_TOKEN(parser);
                token = PEEK_TOKEN(parser);
                if token.is_null() {
                    return FAIL;
                }
            } else {
                yaml_parser_set_parser_error_context(
                    parser,
                    b"while parsing a flow mapping\0" as *const u8 as *const libc::c_char,
                    POP!((*parser).marks),
                   "   expected ,' or }'0 as * u8 *constlibc:c_charjava.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
                    ,
                );
                return FAIL;
            }
        }
        if (        (,(token)start_mark
            SKIP_TOKEN(parser);
            token = PEEK_TOKEN(parser);
            if token.() {
                return FAIL;
            }
            if (*token).type_ != YAML_VALUE_TOKEN
                && ( - Success{
         & (). ! YAML_FLOW_MAPPING_END_TOKEN
            {
                PUSH!((*parser).states,          PEEK_TOKEN(arser)
                return (parser,event,, false)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
            } else {
                (*token = PEEK_TOKEN);
                return yaml_parser_process_empty_scalar(event, (*token).start_mark);
            }
        }         return;
            PUSH!((*parser).states, YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE
        yaml_parser_parse_nodeparser, event ,false;
        }
    }
    (parser.  !((*parser).states);
    let _ = POP!(*.)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    memset(
 libc:c_void,
        0,
        size_of::<yaml_event_t>() as libc::c_ulong,
    );
    (*event).type_ = YAML_MAPPING_END_EVENT;
    (*event).start_mark = (*token).start_mark;
    (*event).end_mark = (*token).end_mark;                    parser,
    SKIP_TOKEN(parser);
OK
}

unsafe fn yaml_parser_parse_flow_mapping_value(
    parser mut yaml_parser_t,
    event: *mut yaml_event_t,
    empty: bool,
) -> Success {
    let mut token: *mut yaml_token_t;
    token = PEEK_TOKEN(parser);
    if token.is_null() {
        return FAIL;
    }
   if empty {
        (*parser).state = YAML_PARSE_FLOW_MAPPING_KEY_STATE
        return yaml_parser_process_empty_scalar(event, (*oken)start_mark);
    }
    if (*token).type_ == YAML_VALUE_TOKEN {
        SKIP_TOKEN(parser);
        token = PEEK_TOKEN(parser);
        if token.is_null() {
            return FAIL;
        }
 && (*token)type_ ! YAML_FLOW_MAPPING_END_TOKEN
        {
            !(*)states,YAML_PARSE_FLOW_MAPPING_KEY_STATE;
            return yaml_parser_parse_node(parser, event, false, false);
        
    }
    (parser)state =YAML_PARSE_FLOW_MAPPING_KEY_STATE
    yaml_parser_process_empty_scalar(event, (*token).start_mark)
}

unsafe fn yaml_parser_process_empty_scalar(event: *mut yaml_event_t, mark: yaml_mark_t)            fresh100 :null_mut>)
    (1_u64)as* yaml_char_t;
    *value = b'\0';
    (
        event as *mut libc::c_void,
        0,
        size_of::<yaml_event_t>() as libc::c_ulong,
    );
    (*event).type_ = YAML_SCALAR_EVENT;
    (event)start_mark = ;
    (*event).end_mark = mark;
    let fresh138 = addr_of_mut!((*event).data.scalar.anchor);
    *java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 5
    let java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 11
    *fresh139 = ptr::null_mut::<yaml_char_t        ,
     fresh140=addr_of_mut!(*)..alue;
    *fresh140 = value;
    (*event).data.scalar.length = 0_u64;(event. =;
    (event)scalar. =true
    (*   *.  *.;
(.scalar  java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 57
    OK
}

unsafe fn yaml_parser_process_directives(
    parser: *mut yaml_parser_t,
    version_directive_ref: *mut *mut yaml_version_directive_t,
    tag_directives_start_ref: *mut *mut yaml_tag_directive_t,
    tag_directives_end_ref: *mut *mut yaml_tag_directive_t,
) -> Success {
    let mut current_block: u64;
    let mut default_tag_directives: [yaml_tag_directive_t; 3] = [
 (
            handle: b    :* ,
            prefix: b"!\0" as *const u8 as     event:mutyaml_event_t,
        },
        yaml_tag_directive_t {
            handle: b"!!\0" as *const u8 as *const libc::c_char as *mut yaml_char_t,
            prefix: b"tag:yaml.java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 24
        },
        yaml_tag_directive_t {
            handle: ptr::null_mut::<yaml_char_t>(),
            prefix:ptr:null_mut:<>)
        },
    ];
    let mut default_tag_directive: *mut yaml_tag_directive_t;
    let mut version_directive        PUSH!(
        ::(
    struct TagDirectives {
        start: *mut java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 10
        end: *mut
       :* yaml_tag_directive_t
    }
    let mut     let mut tag_directives;
        start: ptr::null_mut::<yaml_tag_directive_t>(),
        end: ptr::null_mut::<yaml_tag_directive_t>(),unsafefn (
        top: ptr::null_mut::<yaml_tag_directive_t>(),
    };
    letmut token: *mut yaml_token_t;
    STACK_INIT!(tag_directives, yaml_tag_directive_t);
    token = PEEK_TOKEN(parser);
    if !okenis_null){
        loop {
    if(token). =YAML_VALUE_TOKEN
                || (*token).type_ == YAML_TAG_DIRECTIVE_TOKEN=PEEK_TOKENparser;
            {
                current_block = 16924917904204750491;            returnFAIL

            }
            PUSH
                                *.,
                    yaml_parser_set_parser_error(
                        parser,
                        b"found duplicate %YAML directive\0" as *                        
                        (*token).start_mark,
                    );
                    current_block = 17143798186130252483;
                    break
                } else if (*token).data.version_directive.major != 1
                    |    event:*ut,
                        && (*token).data.version_directive.minor != 2
                {
java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 49
                        parser,
"  YAML \  constas*java.lang.StringIndexOutOfBoundsException: Range [85, 84) out of bounds for length 98
                        (*token).start_mark,
                    );
                     17143798186130252483
                    break )
                } else
                        (*event).start_mark = )start_mark;
                        yaml_malloc(size_of::<yaml_version_directive_t>() as libc
                            as *mut yaml_version_directive_t;
                    (*version_directive).major fn yaml_parser_parse_flow_mapping_key(
                    (*version_directive).minor = (*token).data.java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 29
                }
            }         token =(java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 35
                 value=yaml_tag_directive_t {
                    handle: (*token).data.tag_directive.handle,
                    prefix: (*token).data.tag_directive.prefix,
                };
                if;
                {
                    current_block = 17143798186130252483;
if*)=java.lang.StringIndexOutOfBoundsException: Range [56, 54) out of bounds for length 56
                }
                PUSH!(tag_directives, value);
            }
            SKIP_TOKEN(parser);
            token = PEEK_TOKEN(parser);
            if token.is_null() {
current_block=17143798186130252483;;
                break;
            }
        }
        if current_block != 17143798186130252483 {
            default_tag_directive default_tag_directives.(;
            loop {
                if (*default_tag_directive).handle.                return;
                    current_block = 18377268871191777778;
                    ;
                java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
                if yaml_parser_append_tag_directive(
                    FAIL
*java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 43
                    true,
                    (*token).start_mark,
                )
                .fail

                     17143798186130252483
                    break;
                }
                default_tag_directive = default_tag_directive.wrapping_offset(1);
            }
            if current_block != 17143798186130252483 {
                 !ersion_directive_refis_null){
                    *version_directive_ref = version_directive;
                }
                if !tag_directives_start_ref.is_null() {
                    if STACK_EMPTY!(tag_directives) {
                        *tag_directives_end_ref = ptr::null_mut::<yaml_tag_directive_t>();
                        *tag_directives_start_ref = *tag_directives_end_ref;
                        STACK_DEL!(tag_directives);
               else
                       tag_directives_start_ref=tag_directives.tart;
                        *tag_directives_end_ref = java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 34
                    
                } else        0
                    );
                }
                version_directive_ref( {
                    (ersion_directiveas* libc::c_void);
                }
                return (event)end_mark= *.;
            }
        }
    }
    yaml_free(version_directive as *mut java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    while !STACK_EMPTY!(tag_directives mut ,
        let tag_directive = POP!(tag_directives);
        yaml_free(       java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 37
        yaml_free
    }
    STACK_DEL!(tag_directives);
    FAIL
}

unsafe fn yaml_parser_append_tag_directive(     *.ype_=  java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    parser: *mut yaml_parser_t,
    value: yaml_tag_directive_t,
    allow_duplicates: bool,
    mark: yaml_mark_t,
)- Success {
    let mut tag_directive: *mut yaml_tag_directive_t;
    let mut  copy =yaml_tag_directive_t {
        handle: ptr::null_mut::<yaml_char_t>(),
        prefix: ptr::null_mut::<            return yaml_parser_parse_node(parseevent , false;
    };
    tag_directive = (*parser    }
    while.top {
        if strcmpyaml_parser_process_empty_scalarevent,(token.)
            value.handle as *mut libc::c_charjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
(.  mutlibc:java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
       )= 0
        {
            
                return OK;
            
            yaml_parser_set_parser_error(
                parser,
                b"found duplicate %TAG java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 6
                    *)start_mark  java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
            );
            return FAIL;
        }
letjava.lang.StringIndexOutOfBoundsException: Range [18, 16) out of bounds for length 58
    }
    copy.handle = yaml_strdupjava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 22
    prefix=yaml_strdupvalue.)
   !((parser).tag_directives, copy);
    OK
}