/* End optimization macro defs */

/// this interface is presently not 64-bit clean due to the int len argument
/// and the internal printbuf interface that takes 32-bit int len arguments
/// so the function limits the maximum string size to INT32_MAX (2GB).
/// If the function is called with len == -1 then strlen is called to check
/// the string length is less than INT32_MAX (2GB)
#[no_mangle]
pub unsafe extern "C" fn json_tokener_parse_ex(
    mut tok: *mut crate::src::json_tokener::json_tokener,
    mut str: *const ::core::ffi::c_char,
    mut len: ::core::ffi::c_int,
) -> *mut json_object {
    let mut case_start_3: *const ::core::ffi::c_char = ::core::ptr::null::<::core::ffi::c_char>();
    let mut got_hi_surrogate: ::core::ffi::c_uint = 0;
    let mut case_start_1: *const ::core::ffi::c_char = ::core::ptr::null::<::core::ffi::c_char>();
    let mut case_start_0: *const ::core::ffi::c_char = ::core::ptr::null::<::core::ffi::c_char>();
    let mut case_start: *const ::core::ffi::c_char = ::core::ptr::null::<::core::ffi::c_char>();
    let mut size: ::core::ffi::c_int = 0;
    let mut size_nan: ::core::ffi::c_int = 0;
    let mut size1: ::core::ffi::c_int = 0;
    let mut size2: ::core::ffi::c_int = 0;
    let mut current_block: u64;
    let mut obj: *mut json_object = ::core::ptr::null_mut::<json_object>();
    let mut c: ::core::ffi::c_char = '\u{1}' as i32 as ::core::ffi::c_char;
    let mut oldlocale: locale_t = uselocale(::core::ptr::null_mut::<__locale_struct>());
    let mut newloc: locale_t = ::core::ptr::null_mut::<__locale_struct>();
    (*tok).char_offset = 0 as ::core::ffi::c_int;
    (*tok).err = crate::src::json_tokener::json_tokener_success;

    /* this interface is presently not 64-bit clean due to the int len argument
       and the internal printbuf interface that takes 32-bit int len arguments
       so the function limits the maximum string size to INT32_MAX (2GB).
       If the function is called with len == -1 then strlen is called to check
       the string length is less than INT32_MAX (2GB) */
    if len < -(1 as ::core::ffi::c_int)
        || len == -(1 as ::core::ffi::c_int) && strlen(str) > INT32_MAX as size_t
    {
        (*tok).err = crate::src::json_tokener::json_tokener_error_size;
        return ::core::ptr::null_mut::<json_object>();
    }
    let mut duploc: locale_t = duplocale(oldlocale);
    newloc = newlocale(
        LC_NUMERIC,
        b"C\0" as *const u8 as *const ::core::ffi::c_char,
        duploc,
    );
    // XXX at least Debian 8.4 has a bug in newlocale where it doesn't
    //  change the decimal separator unless you set LC_TIME!
    if !newloc.is_null() {
        duploc = newloc; // original duploc has been freed by newlocale()
        newloc = newlocale(
            LC_TIME,
            b"C\0" as *const u8 as *const ::core::ffi::c_char,
            duploc,
        );
    }
    if newloc.is_null() {
        freelocale(duploc);
        return ::core::ptr::null_mut::<json_object>();
    }
    uselocale(newloc);
    's_68: while if (*tok).char_offset == len {
        if (*tok).depth == 0 as ::core::ffi::c_int
            && (*(*tok).stack.offset((*tok).depth as isize)).state as ::core::ffi::c_uint
                == crate::src::json_tokener::json_tokener_state_eatws as ::core::ffi::c_int as ::core::ffi::c_uint
            && (*(*tok).stack.offset((*tok).depth as isize)).saved_state as ::core::ffi::c_uint
                == crate::src::json_tokener::json_tokener_state_finish as ::core::ffi::c_int as ::core::ffi::c_uint
        {
            (*tok).err = crate::src::json_tokener::json_tokener_success;
            0 as ::core::ffi::c_int
        } else {
            (*tok).err = crate::src::json_tokener::json_tokener_continue;
            0 as ::core::ffi::c_int
        }
    } else {
        c = *str;
        1 as ::core::ffi::c_int
    } != 0
    {
        loop {
            match (*(*tok).stack.offset((*tok).depth as isize)).state as ::core::ffi::c_uint {
                0 => {
                    /* Advance until we change state */
                    while *(*__ctype_b_loc())
                        .offset(c as ::core::ffi::c_uchar as ::core::ffi::c_int as isize)
                        as ::core::ffi::c_int
                        & _ISspace as ::core::ffi::c_int as ::core::ffi::c_ushort
                            as ::core::ffi::c_int
                        != 0
                    {
                        str = str.offset(1);
                        (*tok).char_offset += 1;
                        if c == 0
                            || (if (*tok).char_offset == len {
                                (if (*tok).depth == 0 as ::core::ffi::c_int
                                    && (*(*tok).stack.offset((*tok).depth as isize)).state
                                        as ::core::ffi::c_uint
                                        == crate::src::json_tokener::json_tokener_state_eatws as ::core::ffi::c_int
                                            as ::core::ffi::c_uint
                                    && (*(*tok).stack.offset((*tok).depth as isize)).saved_state
                                        as ::core::ffi::c_uint
                                        == crate::src::json_tokener::json_tokener_state_finish as ::core::ffi::c_int
                                            as ::core::ffi::c_uint
                                {
                                    (*tok).err = crate::src::json_tokener::json_tokener_success;
                                    0 as ::core::ffi::c_int
                                } else {
                                    (*tok).err = crate::src::json_tokener::json_tokener_continue;
                                    0 as ::core::ffi::c_int
                                })
                            } else {
                                c = *str;
                                1 as ::core::ffi::c_int
                            }) == 0
                        {
                            break 's_68;
                        }
                    }
                    if c as ::core::ffi::c_int == '/' as i32
                        && (*tok).flags & crate::src::json_tokener::JSON_TOKENER_STRICT == 0
                    {
                        printbuf_reset((*tok).pb as *mut printbuf);
                        if (*(*tok).pb).size - (*(*tok).pb).bpos > 1 as ::core::ffi::c_int {
                            memcpy(
                                (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                    as *mut ::core::ffi::c_void,
                                &raw mut c as *const ::core::ffi::c_void,
                                1 as size_t,
                            );
                            (*(*tok).pb).bpos += 1 as ::core::ffi::c_int;
                            *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                                '\0' as i32 as ::core::ffi::c_char;
                        } else {
                            printbuf_memappend((*tok).pb as *mut printbuf, &raw mut c, 1 as ::core::ffi::c_int);
                        }
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_comment_start;
                        current_block = 14804750364725543955;
                        break;
                    } else {
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            (*(*tok).stack.offset((*tok).depth as isize)).saved_state;
                    }
                }
                1 => match c as ::core::ffi::c_int {
                    123 => {
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_eatws;
                        (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                            crate::src::json_tokener::json_tokener_state_object_field_start;
                        let ref mut fresh2 = (*(*tok).stack.offset((*tok).depth as isize)).current;
                        *fresh2 =  json_object_new_object() as
    *mut json_object;
                        if (*(*tok).stack.offset((*tok).depth as isize))
                            .current
                            .is_null()
                        {
                            break 's_68;
                        } else {
                            current_block = 14804750364725543955;
                            break;
                        }
                    }
                    91 => {
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_eatws;
                        (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                            crate::src::json_tokener::json_tokener_state_array;
                        let ref mut fresh3 = (*(*tok).stack.offset((*tok).depth as isize)).current;
                        *fresh3 =  json_object_new_array() as
    *mut json_object;
                        if (*(*tok).stack.offset((*tok).depth as isize))
                            .current
                            .is_null()
                        {
                            break 's_68;
                        } else {
                            current_block = 14804750364725543955;
                            break;
                        }
                    }
                    73 | 105 => {
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_inf;
                        printbuf_reset((*tok).pb as *mut printbuf);
                        (*tok).st_pos = 0 as ::core::ffi::c_int;
                    }
                    78 | 110 => {
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_null; // or NaN
                        printbuf_reset((*tok).pb as *mut printbuf);
                        (*tok).st_pos = 0 as ::core::ffi::c_int;
                    }
                    39 => {
                        if (*tok).flags & crate::src::json_tokener::JSON_TOKENER_STRICT != 0 {
                            /* in STRICT mode only double-quote are allowed */
                            current_block = 721385680381463314;
                            break;
                        } else {
                            /* FALLTHRU */
                            current_block = 10520667372580636250;
                            break;
                        }
                    }
                    34 => {
                        current_block = 10520667372580636250;
                        break;
                    }
                    84 | 116 | 70 | 102 => {
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_boolean;
                        printbuf_reset((*tok).pb as *mut printbuf);
                        (*tok).st_pos = 0 as ::core::ffi::c_int;
                    }
                    48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 45 => {
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_number;
                        printbuf_reset((*tok).pb as *mut printbuf);
                        tok->is_double = 0;
                    }
                    _ => {
                        (*tok).err = crate::src::json_tokener::json_tokener_error_parse_unexpected;
                        break 's_68;
                    }
                },
                2 => {
                    if (*tok).depth == 0 as ::core::ffi::c_int {
                        break 's_68;
                    }
                    obj =  json_object_get((*(*tok).stack.offset((*tok).depth as isize)).current as
    *mut json_object) as
    *mut json_object;
                    json_tokener_reset_level(tok, (*tok).depth);
                    (*tok).depth -= 1;
                }
                24 => {
                    /* aka starts with 'i' (or 'I', or "-i", or "-I") */
                    /* If we were guaranteed to have len set, then we could (usually) handle
                     * the entire "Infinity" check in a single strncmp (strncasecmp), but
                     * since len might be -1 (i.e. "read until \0"), we need to check it
                     * a character at a time.
                     * Trying to handle it both ways would make this code considerably more
                     * complicated with likely little performance benefit.
                     */
                    let mut is_negative: ::core::ffi::c_int = 0 as ::core::ffi::c_int;
                    let mut _json_inf_str: *const ::core::ffi::c_char =
                        &raw const json_inf_str as *const ::core::ffi::c_char;
                    if (*tok).flags & crate::src::json_tokener::JSON_TOKENER_STRICT == 0 {
                        _json_inf_str = &raw const json_inf_str_lower as *const ::core::ffi::c_char;
                    }
                    /* Note: tok->st_pos must be 0 when state is set to json_tokener_state_inf */
                    while (*tok).st_pos < json_inf_str_len as ::core::ffi::c_int {
                        let mut inf_char: ::core::ffi::c_char = *str;
                        if (*tok).flags & crate::src::json_tokener::JSON_TOKENER_STRICT == 0 {
                            inf_char = ({
                                let mut __res: ::core::ffi::c_int = 0;
                                if ::core::mem::size_of::<::core::ffi::c_int>() as usize
                                    > 1 as usize
                                {
                                    if 0 != 0 {
                                        let mut __c: ::core::ffi::c_int =
                                            *str as ::core::ffi::c_int;
                                        __res = (if __c < -(128 as ::core::ffi::c_int)
                                            || __c > 255 as ::core::ffi::c_int
                                        {
                                            __c as __int32_t
                                        } else {
                                            *(*__ctype_tolower_loc()).offset(__c as isize)
                                        })
                                            as ::core::ffi::c_int;
                                    } else {
                                        __res = tolower(*str as ::core::ffi::c_int);
                                    }
                                } else {
                                    __res = *(*__ctype_tolower_loc())
                                        .offset(*str as ::core::ffi::c_int as isize)
                                        as ::core::ffi::c_int;
                                }
                                __res
                            }) as ::core::ffi::c_char;
                        }
                        if inf_char as ::core::ffi::c_int
                            != *_json_inf_str.offset((*tok).st_pos as isize) as ::core::ffi::c_int
                        {
                            (*tok).err = crate::src::json_tokener::json_tokener_error_parse_unexpected;
                            break 's_68;
                        } else {
                            (*tok).st_pos += 1;
                            str = str.offset(1);
                            (*tok).char_offset += 1;
                            if if (*tok).char_offset == len {
                                if (*tok).depth == 0 as ::core::ffi::c_int
                                    && (*(*tok).stack.offset((*tok).depth as isize)).state
                                        as ::core::ffi::c_uint
                                        == crate::src::json_tokener::json_tokener_state_eatws as ::core::ffi::c_int
                                            as ::core::ffi::c_uint
                                    && (*(*tok).stack.offset((*tok).depth as isize)).saved_state
                                        as ::core::ffi::c_uint
                                        == crate::src::json_tokener::json_tokener_state_finish as ::core::ffi::c_int
                                            as ::core::ffi::c_uint
                                {
                                    (*tok).err = crate::src::json_tokener::json_tokener_success;
                                    0 as ::core::ffi::c_int
                                } else {
                                    (*tok).err = crate::src::json_tokener::json_tokener_continue;
                                    0 as ::core::ffi::c_int
                                }
                            } else {
                                c = *str;
                                1 as ::core::ffi::c_int
                            } == 0
                            {
                                /* out of input chars, for now at least */
                                break 's_68;
                            }
                        }
                    }
                    /* We checked the full length of "Infinity", so create the object.
                     * When handling -Infinity, the number parsing code will have dropped
                     * the "-" into tok->pb for us, so check it now.
                     */
                    if (*(*tok).pb).bpos > 0 as ::core::ffi::c_int
                        && *(*(*tok).pb).buf as ::core::ffi::c_int == '-' as i32
                    {
                        is_negative = 1 as ::core::ffi::c_int;
                    }
                    let ref mut fresh4 = (*(*tok).stack.offset((*tok).depth as isize)).current;
                    *fresh4 =  json_object_new_double(
                        (if is_negative != 0 {
                            -::core::f32::INFINITY
                        } else {
                            ::core::f32::INFINITY
                        }) as ::core::ffi::c_double,
                    ) as
    *mut json_object;
                    if (*(*tok).stack.offset((*tok).depth as isize))
                        .current
                        .is_null()
                    {
                        break 's_68;
                    }
                    (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                        crate::src::json_tokener::json_tokener_state_finish;
                    (*(*tok).stack.offset((*tok).depth as isize)).state = crate::src::json_tokener::json_tokener_state_eatws;
                }
                3 => {
                    /* aka starts with 'n' */
                    size = 0;
                    size_nan = 0;
                    if (*(*tok).pb).size - (*(*tok).pb).bpos > 1 as ::core::ffi::c_int {
                        memcpy(
                            (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                as *mut ::core::ffi::c_void,
                            &raw mut c as *const ::core::ffi::c_void,
                            1 as size_t,
                        );
                        (*(*tok).pb).bpos += 1 as ::core::ffi::c_int;
                        *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                            '\0' as i32 as ::core::ffi::c_char;
                    } else {
                        printbuf_memappend((*tok).pb as *mut printbuf, &raw mut c, 1 as ::core::ffi::c_int);
                    }
                    size = if ((*tok).st_pos + 1 as ::core::ffi::c_int) < json_null_str_len {
                        (*tok).st_pos + 1 as ::core::ffi::c_int
                    } else {
                        json_null_str_len
                    };
                    size_nan = if ((*tok).st_pos + 1 as ::core::ffi::c_int) < json_nan_str_len {
                        (*tok).st_pos + 1 as ::core::ffi::c_int
                    } else {
                        json_nan_str_len
                    };
                    if (*tok).flags & crate::src::json_tokener::JSON_TOKENER_STRICT == 0
                        && strncasecmp(
                            &raw const json_null_str as *const ::core::ffi::c_char,
                            (*(*tok).pb).buf,
                            size as size_t,
                        ) == 0 as ::core::ffi::c_int
                        || strncmp(
                            &raw const json_null_str as *const ::core::ffi::c_char,
                            (*(*tok).pb).buf,
                            size as size_t,
                        ) == 0 as ::core::ffi::c_int
                    {
                        if !((*tok).st_pos == json_null_str_len) {
                            current_block = 15447629348493591490;
                            break;
                        }
                        let ref mut fresh5 = (*(*tok).stack.offset((*tok).depth as isize)).current;
                        *fresh5 = ::core::ptr::null_mut::<json_object>();
                        (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                            crate::src::json_tokener::json_tokener_state_finish;
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_eatws;
                    } else if (*tok).flags & crate::src::json_tokener::JSON_TOKENER_STRICT == 0
                        && strncasecmp(
                            &raw const json_nan_str as *const ::core::ffi::c_char,
                            (*(*tok).pb).buf,
                            size_nan as size_t,
                        ) == 0 as ::core::ffi::c_int
                        || strncmp(
                            &raw const json_nan_str as *const ::core::ffi::c_char,
                            (*(*tok).pb).buf,
                            size_nan as size_t,
                        ) == 0 as ::core::ffi::c_int
                    {
                        if !((*tok).st_pos == json_nan_str_len) {
                            current_block = 15447629348493591490;
                            break;
                        }
                        let ref mut fresh6 = (*(*tok).stack.offset((*tok).depth as isize)).current;
                        *fresh6 =  json_object_new_double(::core::f32::NAN as ::core::ffi::c_double) as
    *mut json_object;
                        if (*(*tok).stack.offset((*tok).depth as isize))
                            .current
                            .is_null()
                        {
                            break 's_68;
                        }
                        (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                            crate::src::json_tokener::json_tokener_state_finish;
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_eatws;
                    } else {
                        (*tok).err = crate::src::json_tokener::json_tokener_error_parse_null;
                        break 's_68;
                    }
                }
                4 => {
                    if c as ::core::ffi::c_int == '*' as i32 {
                        current_block = 2904036176499606090;
                        break;
                    } else {
                        current_block = 14155412868135599428;
                        break;
                    }
                }
                5 => {
                    /* Advance until we change state */
                    case_start = str;
                    current_block = 14652688882591975137;
                    break;
                }
                6 => {
                    /* Advance until we change state */
                    case_start_0 = str;
                    current_block = 15321816652064063775;
                    break;
                }
                7 => {
                    if (*(*tok).pb).size - (*(*tok).pb).bpos > 1 as ::core::ffi::c_int {
                        memcpy(
                            (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                as *mut ::core::ffi::c_void,
                            &raw mut c as *const ::core::ffi::c_void,
                            1 as size_t,
                        );
                        (*(*tok).pb).bpos += 1 as ::core::ffi::c_int;
                        *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                            '\0' as i32 as ::core::ffi::c_char;
                    } else {
                        printbuf_memappend((*tok).pb as *mut printbuf, &raw mut c, 1 as ::core::ffi::c_int);
                    }
                    if c as ::core::ffi::c_int == '/' as i32 {
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_eatws;
                    } else {
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_comment;
                    }
                    current_block = 14804750364725543955;
                    break;
                }
                8 => {
                    /* Advance until we change state */
                    case_start_1 = str;
                    current_block = 4127803603908737533;
                    break;
                }
                9 => match c as ::core::ffi::c_int {
                    34 | 92 | 47 => {
                        current_block = 11715598964735866444;
                        break;
                    }
                    98 | 110 | 114 | 116 | 102 => {
                        current_block = 16382715083403891171;
                        break;
                    }
                    117 => {
                        current_block = 10482649921445892870;
                        break;
                    }
                    _ => {
                        current_block = 10441871917347885951;
                        break;
                    }
                },
                10 => {
                    got_hi_surrogate = 0 as ::core::ffi::c_uint;
                    current_block = 9832207539762953715;
                    break;
                }
                11 => {
                    size1 = 0;
                    size2 = 0;
                    if (*(*tok).pb).size - (*(*tok).pb).bpos > 1 as ::core::ffi::c_int {
                        memcpy(
                            (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                as *mut ::core::ffi::c_void,
                            &raw mut c as *const ::core::ffi::c_void,
                            1 as size_t,
                        );
                        (*(*tok).pb).bpos += 1 as ::core::ffi::c_int;
                        *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                            '\0' as i32 as ::core::ffi::c_char;
                    } else {
                        printbuf_memappend((*tok).pb as *mut printbuf, &raw mut c, 1 as ::core::ffi::c_int);
                    }
                    size1 = if ((*tok).st_pos + 1 as ::core::ffi::c_int) < json_true_str_len {
                        (*tok).st_pos + 1 as ::core::ffi::c_int
                    } else {
                        json_true_str_len
                    };
                    size2 = if ((*tok).st_pos + 1 as ::core::ffi::c_int) < json_false_str_len {
                        (*tok).st_pos + 1 as ::core::ffi::c_int
                    } else {
                        json_false_str_len
                    };
                    if (*tok).flags & crate::src::json_tokener::JSON_TOKENER_STRICT == 0
                        && strncasecmp(
                            &raw const json_true_str as *const ::core::ffi::c_char,
                            (*(*tok).pb).buf,
                            size1 as size_t,
                        ) == 0 as ::core::ffi::c_int
                        || strncmp(
                            &raw const json_true_str as *const ::core::ffi::c_char,
                            (*(*tok).pb).buf,
                            size1 as size_t,
                        ) == 0 as ::core::ffi::c_int
                    {
                        if !((*tok).st_pos == json_true_str_len) {
                            current_block = 3871889238474132049;
                            break;
                        }
                        let ref mut fresh9 = (*(*tok).stack.offset((*tok).depth as isize)).current;
                        *fresh9 =  json_object_new_boolean(1 as json_bool) as
    *mut json_object;
                        if (*(*tok).stack.offset((*tok).depth as isize))
                            .current
                            .is_null()
                        {
                            break 's_68;
                        }
                        (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                            crate::src::json_tokener::json_tokener_state_finish;
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_eatws;
                    } else if (*tok).flags & crate::src::json_tokener::JSON_TOKENER_STRICT == 0
                        && strncasecmp(
                            &raw const json_false_str as *const ::core::ffi::c_char,
                            (*(*tok).pb).buf,
                            size2 as size_t,
                        ) == 0 as ::core::ffi::c_int
                        || strncmp(
                            &raw const json_false_str as *const ::core::ffi::c_char,
                            (*(*tok).pb).buf,
                            size2 as size_t,
                        ) == 0 as ::core::ffi::c_int
                    {
                        if !((*tok).st_pos == json_false_str_len) {
                            current_block = 3871889238474132049;
                            break;
                        }
                        let ref mut fresh10 = (*(*tok).stack.offset((*tok).depth as isize)).current;
                        *fresh10 =  json_object_new_boolean(0 as json_bool) as
    *mut json_object;
                        if (*(*tok).stack.offset((*tok).depth as isize))
                            .current
                            .is_null()
                        {
                            break 's_68;
                        }
                        (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                            crate::src::json_tokener::json_tokener_state_finish;
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_eatws;
                    } else {
                        (*tok).err = crate::src::json_tokener::json_tokener_error_parse_boolean;
                        break 's_68;
                    }
                }
                12 => {
                    /* Advance until we change state */
                    let mut case_start_2: *const ::core::ffi::c_char = str;
                    let mut case_len: ::core::ffi::c_int = 0 as ::core::ffi::c_int;
                    let mut is_exponent: ::core::ffi::c_int = 0 as ::core::ffi::c_int;
                    let mut negativesign_next_possible_location: ::core::ffi::c_int =
                        1 as ::core::ffi::c_int;
                    while c as ::core::ffi::c_int != 0
                        && !strchr(json_number_chars, c as ::core::ffi::c_int).is_null()
                    {
                        case_len += 1;

                        /* non-digit characters checks */
                        /* note: since the main loop condition to get here was
                                 an input starting with 0-9 or '-', we are
                                 protected from input starting with '.' or
                                 e/E. */
                        if c as ::core::ffi::c_int == '.' as i32 {
                            if (*tok).is_double != 0 as ::core::ffi::c_int {
                                /* '.' can only be found once, and out of the exponent part.
                                   Thus, if the input is already flagged as double, it
                                   is invalid. */
                                (*tok).err = crate::src::json_tokener::json_tokener_error_parse_number;
                                break 's_68;
                            } else {
                                (*tok).is_double = 1 as ::core::ffi::c_int;
                            }
                        }
                        if c as ::core::ffi::c_int == 'e' as i32
                            || c as ::core::ffi::c_int == 'E' as i32
                        {
                            if is_exponent != 0 as ::core::ffi::c_int {
                                /* only one exponent possible */
                                (*tok).err = crate::src::json_tokener::json_tokener_error_parse_number;
                                break 's_68;
                            } else {
                                is_exponent = 1 as ::core::ffi::c_int;
                                (*tok).is_double = 1 as ::core::ffi::c_int;
                                /* the exponent part can begin with a negative sign */
                                negativesign_next_possible_location =
                                    case_len + 1 as ::core::ffi::c_int;
                            }
                        }
                        if c as ::core::ffi::c_int == '-' as i32
                            && case_len != negativesign_next_possible_location
                        {
                            /* If the negative sign is not where expected (ie
                               start of input or start of exponent part), the
                               input is invalid. */
                            (*tok).err = crate::src::json_tokener::json_tokener_error_parse_number;
                            break 's_68;
                        } else {
                            str = str.offset(1);
                            (*tok).char_offset += 1;
                            if !(c == 0
                                || (if (*tok).char_offset == len {
                                    (if (*tok).depth == 0 as ::core::ffi::c_int
                                        && (*(*tok).stack.offset((*tok).depth as isize)).state
                                            as ::core::ffi::c_uint
                                            == crate::src::json_tokener::json_tokener_state_eatws as ::core::ffi::c_int
                                                as ::core::ffi::c_uint
                                        && (*(*tok).stack.offset((*tok).depth as isize)).saved_state
                                            as ::core::ffi::c_uint
                                            == crate::src::json_tokener::json_tokener_state_finish as ::core::ffi::c_int
                                                as ::core::ffi::c_uint
                                    {
                                        (*tok).err = crate::src::json_tokener::json_tokener_success;
                                        0 as ::core::ffi::c_int
                                    } else {
                                        (*tok).err = crate::src::json_tokener::json_tokener_continue;
                                        0 as ::core::ffi::c_int
                                    })
                                } else {
                                    c = *str;
                                    1 as ::core::ffi::c_int
                                }) == 0)
                            {
                                continue;
                            }
                            if (*(*tok).pb).size - (*(*tok).pb).bpos > case_len {
                                memcpy(
                                    (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                        as *mut ::core::ffi::c_void,
                                    case_start_2 as *const ::core::ffi::c_void,
                                    case_len as size_t,
                                );
                                (*(*tok).pb).bpos += case_len;
                                *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                                    '\0' as i32 as ::core::ffi::c_char;
                            } else {
                                printbuf_memappend((*tok).pb as *mut printbuf, case_start_2, case_len);
                            }
                            break 's_68;
                        }
                    }
                    if case_len > 0 as ::core::ffi::c_int {
                        if (*(*tok).pb).size - (*(*tok).pb).bpos > case_len {
                            memcpy(
                                (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                    as *mut ::core::ffi::c_void,
                                case_start_2 as *const ::core::ffi::c_void,
                                case_len as size_t,
                            );
                            (*(*tok).pb).bpos += case_len;
                            *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                                '\0' as i32 as ::core::ffi::c_char;
                        } else {
                            printbuf_memappend((*tok).pb as *mut printbuf, case_start_2, case_len);
                        }
                    }

                    // Check for -Infinity
                    if *(*(*tok).pb).buf.offset(0 as ::core::ffi::c_int as isize)
                        as ::core::ffi::c_int
                        == '-' as i32
                        && case_len <= 1 as ::core::ffi::c_int
                        && (c as ::core::ffi::c_int == 'i' as i32
                            || c as ::core::ffi::c_int == 'I' as i32)
                    {
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_inf;
                        (*tok).st_pos = 0 as ::core::ffi::c_int;
                    } else {
                        let mut num64: int64_t = 0;
                        let mut numd: ::core::ffi::c_double = 0.;
                        if (*tok).is_double == 0
                            && json_parse_int64((*(*tok).pb).buf, &raw mut num64)
                                == 0 as ::core::ffi::c_int
                        {
                            if num64 != 0
                                && *(*(*tok).pb).buf.offset(0 as ::core::ffi::c_int as isize)
                                    as ::core::ffi::c_int
                                    == '0' as i32
                                && (*tok).flags & crate::src::json_tokener::JSON_TOKENER_STRICT != 0
                            {
                                /* in strict mode, number must not start with 0 */
                                (*tok).err = crate::src::json_tokener::json_tokener_error_parse_number;
                                break 's_68;
                            } else {
                                let ref mut fresh11 =
                                    (*(*tok).stack.offset((*tok).depth as isize)).current;
                                *fresh11 =  json_object_new_int64(num64) as
    *mut json_object;
                                if (*(*tok).stack.offset((*tok).depth as isize))
                                    .current
                                    .is_null()
                                {
                                    break 's_68;
                                }
                            }
                        } else if (*tok).is_double != 0
                            && json_parse_double((*(*tok).pb).buf, &raw mut numd)
                                == 0 as ::core::ffi::c_int
                        {
                            let ref mut fresh12 =
                                (*(*tok).stack.offset((*tok).depth as isize)).current;
                            *fresh12 =  json_object_new_double_s(numd, (*(*tok).pb).buf) as
    *mut json_object;
                            if (*(*tok).stack.offset((*tok).depth as isize))
                                .current
                                .is_null()
                            {
                                break 's_68;
                            }
                        } else {
                            (*tok).err = crate::src::json_tokener::json_tokener_error_parse_number;
                            break 's_68;
                        }
                        (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                            crate::src::json_tokener::json_tokener_state_finish;
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_eatws;
                    }
                }
                22 | 13 => {
                    if c as ::core::ffi::c_int == ']' as i32 {
                        if (*(*tok).stack.offset((*tok).depth as isize)).state
                            as ::core::ffi::c_uint
                            == crate::src::json_tokener::json_tokener_state_array_after_sep as ::core::ffi::c_int
                                as ::core::ffi::c_uint
                            && (*tok).flags & crate::src::json_tokener::JSON_TOKENER_STRICT != 0
                        {
                            current_block = 7381833562023054431;
                            break;
                        } else {
                            current_block = 17216701700680750999;
                            break;
                        }
                    } else if (*tok).depth >= (*tok).max_depth - 1 as ::core::ffi::c_int {
                        (*tok).err = crate::src::json_tokener::json_tokener_error_depth;
                        break 's_68;
                    } else {
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_array_add;
                        (*tok).depth += 1;
                        json_tokener_reset_level(tok, (*tok).depth);
                    }
                }
                14 => {
                    if json_object_array_add(
                        
                        (*(*tok).stack.offset((*tok).depth as isize)).current as
    *mut json_object,
                        
                        obj as *mut json_object,
                    ) != 0 as ::core::ffi::c_int
                    {
                        break 's_68;
                    }
                    (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                        crate::src::json_tokener::json_tokener_state_array_sep;
                    (*(*tok).stack.offset((*tok).depth as isize)).state = crate::src::json_tokener::json_tokener_state_eatws;
                }
                15 => {
                    if c as ::core::ffi::c_int == ']' as i32 {
                        current_block = 8258632986558375165;
                        break;
                    } else if c as ::core::ffi::c_int == ',' as i32 {
                        current_block = 1221455853722280505;
                        break;
                    } else {
                        (*tok).err = crate::src::json_tokener::json_tokener_error_parse_array;
                        break 's_68;
                    }
                }
                16 | 23 => {
                    if c as ::core::ffi::c_int == '}' as i32 {
                        current_block = 498610233103725363;
                        break;
                    } else {
                        current_block = 17415828221296073774;
                        break;
                    }
                }
                17 => {
                    /* Advance until we change state */
                    case_start_3 = str;
                    current_block = 2358125959230175008;
                    break;
                }
                18 => {
                    if c as ::core::ffi::c_int == ':' as i32 {
                        current_block = 18339326955861451691;
                        break;
                    } else {
                        current_block = 10531606853991144752;
                        break;
                    }
                }
                19 => {
                    if (*tok).depth >= (*tok).max_depth - 1 as ::core::ffi::c_int {
                        (*tok).err = crate::src::json_tokener::json_tokener_error_depth;
                        break 's_68;
                    } else {
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_object_value_add;
                        (*tok).depth += 1;
                        json_tokener_reset_level(tok, (*tok).depth);
                    }
                }
                20 => {
                    json_object_object_add(
                        
                        (*(*tok).stack.offset((*tok).depth as isize)).current as
    *mut json_object,
                        (*(*tok).stack.offset((*tok).depth as isize)).obj_field_name,
                        
                        obj as *mut json_object,
                    );
                    free(
                        (*(*tok).stack.offset((*tok).depth as isize)).obj_field_name
                            as *mut ::core::ffi::c_void,
                    );
                    let ref mut fresh14 =
                        (*(*tok).stack.offset((*tok).depth as isize)).obj_field_name;
                    *fresh14 = ::core::ptr::null_mut::<::core::ffi::c_char>();
                    (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                        crate::src::json_tokener::json_tokener_state_object_sep;
                    (*(*tok).stack.offset((*tok).depth as isize)).state = crate::src::json_tokener::json_tokener_state_eatws;
                }
                21 => {
                    /* { */
                    if c as ::core::ffi::c_int == '}' as i32 {
                        current_block = 11211850645214766980;
                        break;
                    } else if c as ::core::ffi::c_int == ',' as i32 {
                        current_block = 5426651279144860038;
                        break;
                    } else {
                        (*tok).err = crate::src::json_tokener::json_tokener_error_parse_object_value_sep;
                        break 's_68;
                    }
                }
                _ => {
                    current_block = 14804750364725543955;
                    break;
                }
            }
        }
        match current_block {
            2358125959230175008 => {
                loop {
                    if c as ::core::ffi::c_int == (*tok).quote_char as ::core::ffi::c_int {
                        if ((*(*tok).pb).size - (*(*tok).pb).bpos) as ::core::ffi::c_long
                            > str.offset_from(case_start_3) as ::core::ffi::c_long
                        {
                            memcpy(
                                (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                    as *mut ::core::ffi::c_void,
                                case_start_3 as *const ::core::ffi::c_void,
                                str.offset_from(case_start_3) as ::core::ffi::c_long as size_t,
                            );
                            (*(*tok).pb).bpos = ((*(*tok).pb).bpos as ::core::ffi::c_long
                                + str.offset_from(case_start_3) as ::core::ffi::c_long)
                                as ::core::ffi::c_int;
                            *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                                '\0' as i32 as ::core::ffi::c_char;
                        } else {
                            printbuf_memappend(
                                
                                (*tok).pb as *mut printbuf,
                                case_start_3,
                                str.offset_from(case_start_3) as ::core::ffi::c_long
                                    as ::core::ffi::c_int,
                            );
                        }
                        let ref mut fresh13 =
                            (*(*tok).stack.offset((*tok).depth as isize)).obj_field_name;
                        *fresh13 = strdup((*(*tok).pb).buf);
                        (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                            crate::src::json_tokener::json_tokener_state_object_field_end;
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_eatws;
                        break;
                    } else if c as ::core::ffi::c_int == '\\' as i32 {
                        if ((*(*tok).pb).size - (*(*tok).pb).bpos) as ::core::ffi::c_long
                            > str.offset_from(case_start_3) as ::core::ffi::c_long
                        {
                            memcpy(
                                (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                    as *mut ::core::ffi::c_void,
                                case_start_3 as *const ::core::ffi::c_void,
                                str.offset_from(case_start_3) as ::core::ffi::c_long as size_t,
                            );
                            (*(*tok).pb).bpos = ((*(*tok).pb).bpos as ::core::ffi::c_long
                                + str.offset_from(case_start_3) as ::core::ffi::c_long)
                                as ::core::ffi::c_int;
                            *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                                '\0' as i32 as ::core::ffi::c_char;
                        } else {
                            printbuf_memappend(
                                
                                (*tok).pb as *mut printbuf,
                                case_start_3,
                                str.offset_from(case_start_3) as ::core::ffi::c_long
                                    as ::core::ffi::c_int,
                            );
                        }
                        (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                            crate::src::json_tokener::json_tokener_state_object_field;
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_string_escape;
                        break;
                    } else {
                        str = str.offset(1);
                        (*tok).char_offset += 1;
                        if !(c == 0
                            || (if (*tok).char_offset == len {
                                (if (*tok).depth == 0 as ::core::ffi::c_int
                                    && (*(*tok).stack.offset((*tok).depth as isize)).state
                                        as ::core::ffi::c_uint
                                        == crate::src::json_tokener::json_tokener_state_eatws as ::core::ffi::c_int
                                            as ::core::ffi::c_uint
                                    && (*(*tok).stack.offset((*tok).depth as isize)).saved_state
                                        as ::core::ffi::c_uint
                                        == crate::src::json_tokener::json_tokener_state_finish as ::core::ffi::c_int
                                            as ::core::ffi::c_uint
                                {
                                    (*tok).err = crate::src::json_tokener::json_tokener_success;
                                    0 as ::core::ffi::c_int
                                } else {
                                    (*tok).err = crate::src::json_tokener::json_tokener_continue;
                                    0 as ::core::ffi::c_int
                                })
                            } else {
                                c = *str;
                                1 as ::core::ffi::c_int
                            }) == 0)
                        {
                            continue;
                        }
                        if ((*(*tok).pb).size - (*(*tok).pb).bpos) as ::core::ffi::c_long
                            > str.offset_from(case_start_3) as ::core::ffi::c_long
                        {
                            memcpy(
                                (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                    as *mut ::core::ffi::c_void,
                                case_start_3 as *const ::core::ffi::c_void,
                                str.offset_from(case_start_3) as ::core::ffi::c_long as size_t,
                            );
                            (*(*tok).pb).bpos = ((*(*tok).pb).bpos as ::core::ffi::c_long
                                + str.offset_from(case_start_3) as ::core::ffi::c_long)
                                as ::core::ffi::c_int;
                            *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                                '\0' as i32 as ::core::ffi::c_char;
                        } else {
                            printbuf_memappend(
                                
                                (*tok).pb as *mut printbuf,
                                case_start_3,
                                str.offset_from(case_start_3) as ::core::ffi::c_long
                                    as ::core::ffi::c_int,
                            );
                        }
                        break 's_68;
                    }
                }
                current_block = 14804750364725543955;
            }
            5426651279144860038 => {
                if c as ::core::ffi::c_int == ',' as i32 {
                    (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                        crate::src::json_tokener::json_tokener_state_object_field_start_after_sep;
                    (*(*tok).stack.offset((*tok).depth as isize)).state = crate::src::json_tokener::json_tokener_state_eatws;
                } else {
                    (*tok).err = crate::src::json_tokener::json_tokener_error_parse_object_value_sep;
                    break;
                }
                current_block = 14804750364725543955;
            }
            17415828221296073774 => {
                if c as ::core::ffi::c_int == '"' as i32 || c as ::core::ffi::c_int == '\'' as i32 {
                    (*tok).quote_char = c;
                    printbuf_reset((*tok).pb as *mut printbuf);
                    (*(*tok).stack.offset((*tok).depth as isize)).state =
                        crate::src::json_tokener::json_tokener_state_object_field;
                } else {
                    (*tok).err = crate::src::json_tokener::json_tokener_error_parse_object_key_name;
                    break;
                }
                current_block = 14804750364725543955;
            }
            498610233103725363 => {
                if (*(*tok).stack.offset((*tok).depth as isize)).state as ::core::ffi::c_uint
                    == crate::src::json_tokener::json_tokener_state_object_field_start_after_sep as ::core::ffi::c_int
                        as ::core::ffi::c_uint
                    && (*tok).flags & crate::src::json_tokener::JSON_TOKENER_STRICT != 0
                {
                    (*tok).err = crate::src::json_tokener::json_tokener_error_parse_unexpected;
                    break;
                } else {
                    (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                        crate::src::json_tokener::json_tokener_state_finish;
                    (*(*tok).stack.offset((*tok).depth as isize)).state = crate::src::json_tokener::json_tokener_state_eatws;
                }
                current_block = 14804750364725543955;
            }
            1221455853722280505 => {
                if c as ::core::ffi::c_int == ',' as i32 {
                    (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                        crate::src::json_tokener::json_tokener_state_array_after_sep;
                    (*(*tok).stack.offset((*tok).depth as isize)).state = crate::src::json_tokener::json_tokener_state_eatws;
                } else {
                    (*tok).err = crate::src::json_tokener::json_tokener_error_parse_array;
                    break;
                }
                current_block = 14804750364725543955;
            }
            17216701700680750999 => {
                (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                    crate::src::json_tokener::json_tokener_state_finish;
                (*(*tok).stack.offset((*tok).depth as isize)).state = crate::src::json_tokener::json_tokener_state_eatws;
                current_block = 14804750364725543955;
            }
            9832207539762953715 => {
                /* Handle a 4-byte sequence, or two sequences if a surrogate pair */
                loop {
                    if c as ::core::ffi::c_int != 0
                        && !strchr(json_hex_chars, c as ::core::ffi::c_int).is_null()
                    {
                        let fresh8 = (*tok).st_pos;
                        (*tok).st_pos = (*tok).st_pos + 1;
                        (*tok).ucs_char = (*tok).ucs_char.wrapping_add(
                            ((if c as ::core::ffi::c_int <= '9' as i32 {
                                c as ::core::ffi::c_int - '0' as i32
                            } else {
                                (c as ::core::ffi::c_int & 7 as ::core::ffi::c_int)
                                    + 9 as ::core::ffi::c_int
                            }) as ::core::ffi::c_uint)
                                << (3 as ::core::ffi::c_int - fresh8) * 4 as ::core::ffi::c_int,
                        );
                        if (*tok).st_pos == 4 as ::core::ffi::c_int {
                            let mut unescaped_utf: [::core::ffi::c_uchar; 4] = [0; 4];
                            if got_hi_surrogate != 0 {
                                if (*tok).ucs_char & 0xfc00 as ::core::ffi::c_uint
                                    == 0xdc00 as ::core::ffi::c_uint
                                {
                                    /* Recalculate the ucs_char, then fall thru to process normally */
                                    (*tok).ucs_char = ((got_hi_surrogate
                                        & 0x3ff as ::core::ffi::c_uint)
                                        << 10 as ::core::ffi::c_int)
                                        .wrapping_add(
                                            (*tok).ucs_char & 0x3ff as ::core::ffi::c_uint,
                                        )
                                        .wrapping_add(
                                            0x10000 as ::core::ffi::c_int as ::core::ffi::c_uint,
                                        );
                                } else if (*(*tok).pb).size - (*(*tok).pb).bpos
                                    > 3 as ::core::ffi::c_int
                                {
                                    /* Hi surrogate was not followed by a low surrogate */
                                    /* Replace the hi and process the rest normally */
                                    memcpy(
                                        (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                            as *mut ::core::ffi::c_void,
                                        &raw mut utf8_replacement_char as *mut ::core::ffi::c_uchar
                                            as *mut ::core::ffi::c_char
                                            as *const ::core::ffi::c_void,
                                        3 as size_t,
                                    );
                                    (*(*tok).pb).bpos += 3 as ::core::ffi::c_int;
                                    *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                                        '\0' as i32 as ::core::ffi::c_char;
                                } else {
                                    /* Hi surrogate was not followed by a low surrogate */
                                    /* Replace the hi and process the rest normally */
                                    printbuf_memappend(
                                        
                                        (*tok).pb as *mut printbuf,
                                        &raw mut utf8_replacement_char as *mut ::core::ffi::c_uchar
                                            as *mut ::core::ffi::c_char,
                                        3 as ::core::ffi::c_int,
                                    );
                                }
                                got_hi_surrogate = 0 as ::core::ffi::c_uint;
                            }
                            if (*tok).ucs_char < 0x80 as ::core::ffi::c_uint {
                                unescaped_utf[0 as ::core::ffi::c_int as usize] =
                                    (*tok).ucs_char as ::core::ffi::c_uchar;
                                if (*(*tok).pb).size - (*(*tok).pb).bpos > 1 as ::core::ffi::c_int {
                                    memcpy(
                                        (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                            as *mut ::core::ffi::c_void,
                                        &raw mut unescaped_utf as *mut ::core::ffi::c_uchar
                                            as *mut ::core::ffi::c_char
                                            as *const ::core::ffi::c_void,
                                        1 as size_t,
                                    );
                                    (*(*tok).pb).bpos += 1 as ::core::ffi::c_int;
                                    *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                                        '\0' as i32 as ::core::ffi::c_char;
                                } else {
                                    printbuf_memappend(
                                        
                                        (*tok).pb as *mut printbuf,
                                        &raw mut unescaped_utf as *mut ::core::ffi::c_uchar
                                            as *mut ::core::ffi::c_char,
                                        1 as ::core::ffi::c_int,
                                    );
                                }
                            } else if (*tok).ucs_char < 0x800 as ::core::ffi::c_uint {
                                unescaped_utf[0 as ::core::ffi::c_int as usize] = (0xc0
                                    as ::core::ffi::c_uint
                                    | (*tok).ucs_char >> 6 as ::core::ffi::c_int)
                                    as ::core::ffi::c_uchar;
                                unescaped_utf[1 as ::core::ffi::c_int as usize] = (0x80
                                    as ::core::ffi::c_uint
                                    | (*tok).ucs_char & 0x3f as ::core::ffi::c_uint)
                                    as ::core::ffi::c_uchar;
                                if (*(*tok).pb).size - (*(*tok).pb).bpos > 2 as ::core::ffi::c_int {
                                    memcpy(
                                        (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                            as *mut ::core::ffi::c_void,
                                        &raw mut unescaped_utf as *mut ::core::ffi::c_uchar
                                            as *mut ::core::ffi::c_char
                                            as *const ::core::ffi::c_void,
                                        2 as size_t,
                                    );
                                    (*(*tok).pb).bpos += 2 as ::core::ffi::c_int;
                                    *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                                        '\0' as i32 as ::core::ffi::c_char;
                                } else {
                                    printbuf_memappend(
                                        
                                        (*tok).pb as *mut printbuf,
                                        &raw mut unescaped_utf as *mut ::core::ffi::c_uchar
                                            as *mut ::core::ffi::c_char,
                                        2 as ::core::ffi::c_int,
                                    );
                                }
                            } else if (*tok).ucs_char & 0xfc00 as ::core::ffi::c_uint
                                == 0xd800 as ::core::ffi::c_uint
                            {
                                /* Got a high surrogate.  Remember it and look for the
                                 * the beginning of another sequence, which should be the
                                 * low surrogate.
                                 */
                                got_hi_surrogate = (*tok).ucs_char;
                                /* Not at end, and the next two chars should be "\u" */
                                if (len == -(1 as ::core::ffi::c_int)
                                    || len > (*tok).char_offset + 2 as ::core::ffi::c_int)
                                    && *str.offset(1 as ::core::ffi::c_int as isize)
                                        as ::core::ffi::c_int
                                        == '\\' as i32
                                    && *str.offset(2 as ::core::ffi::c_int as isize)
                                        as ::core::ffi::c_int
                                        == 'u' as i32
                                {
                                    /* Advance through the 16 bit surrogate, and move on to the
                                     * next sequence. The next step is to process the following
                                     * characters.
                                     */
                                    str = str.offset(1);
                                    (*tok).char_offset += 1;
                                    if c == 0 || {
                                        str = str.offset(1);
                                        (*tok).char_offset += 1;
                                        c == 0
                                    } {
                                        if (*(*tok).pb).size - (*(*tok).pb).bpos
                                            > 3 as ::core::ffi::c_int
                                        {
                                            memcpy(
                                                (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                                    as *mut ::core::ffi::c_void,
                                                &raw mut utf8_replacement_char
                                                    as *mut ::core::ffi::c_uchar
                                                    as *mut ::core::ffi::c_char
                                                    as *const ::core::ffi::c_void,
                                                3 as size_t,
                                            );
                                            (*(*tok).pb).bpos += 3 as ::core::ffi::c_int;
                                            *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                                                '\0' as i32 as ::core::ffi::c_char;
                                        } else {
                                            printbuf_memappend(
                                                
                                                (*tok).pb as *mut printbuf,
                                                &raw mut utf8_replacement_char
                                                    as *mut ::core::ffi::c_uchar
                                                    as *mut ::core::ffi::c_char,
                                                3 as ::core::ffi::c_int,
                                            );
                                        }
                                    }
                                    /* Advance to the first char of the next sequence and
                                     * continue processing with the next sequence.
                                     */
                                    str = str.offset(1);
                                    (*tok).char_offset += 1;
                                    if c == 0
                                        || (if (*tok).char_offset == len {
                                            (if (*tok).depth == 0 as ::core::ffi::c_int
                                                && (*(*tok).stack.offset((*tok).depth as isize))
                                                    .state
                                                    as ::core::ffi::c_uint
                                                    == crate::src::json_tokener::json_tokener_state_eatws
                                                        as ::core::ffi::c_int
                                                        as ::core::ffi::c_uint
                                                && (*(*tok).stack.offset((*tok).depth as isize))
                                                    .saved_state
                                                    as ::core::ffi::c_uint
                                                    == crate::src::json_tokener::json_tokener_state_finish
                                                        as ::core::ffi::c_int
                                                        as ::core::ffi::c_uint
                                            {
                                                (*tok).err = crate::src::json_tokener::json_tokener_success;
                                                0 as ::core::ffi::c_int
                                            } else {
                                                (*tok).err = crate::src::json_tokener::json_tokener_continue;
                                                0 as ::core::ffi::c_int
                                            })
                                        } else {
                                            c = *str;
                                            1 as ::core::ffi::c_int
                                        }) == 0
                                    {
                                        if (*(*tok).pb).size - (*(*tok).pb).bpos
                                            > 3 as ::core::ffi::c_int
                                        {
                                            memcpy(
                                                (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                                    as *mut ::core::ffi::c_void,
                                                &raw mut utf8_replacement_char
                                                    as *mut ::core::ffi::c_uchar
                                                    as *mut ::core::ffi::c_char
                                                    as *const ::core::ffi::c_void,
                                                3 as size_t,
                                            );
                                            (*(*tok).pb).bpos += 3 as ::core::ffi::c_int;
                                            *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                                                '\0' as i32 as ::core::ffi::c_char;
                                        } else {
                                            printbuf_memappend(
                                                
                                                (*tok).pb as *mut printbuf,
                                                &raw mut utf8_replacement_char
                                                    as *mut ::core::ffi::c_uchar
                                                    as *mut ::core::ffi::c_char,
                                                3 as ::core::ffi::c_int,
                                            );
                                        }
                                        break 's_68;
                                    } else {
                                        (*tok).ucs_char = 0 as ::core::ffi::c_uint;
                                        (*tok).st_pos = 0 as ::core::ffi::c_int;
                                        continue; /* other json_tokener_state_escape_unicode */
                                    }
                                } else if (*(*tok).pb).size - (*(*tok).pb).bpos
                                    > 3 as ::core::ffi::c_int
                                {
                                    /* Got a high surrogate without another sequence following
                                     * it.  Put a replacement char in for the hi surrogate
                                     * and pretend we finished.
                                     */
                                    memcpy(
                                        (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                            as *mut ::core::ffi::c_void,
                                        &raw mut utf8_replacement_char as *mut ::core::ffi::c_uchar
                                            as *mut ::core::ffi::c_char
                                            as *const ::core::ffi::c_void,
                                        3 as size_t,
                                    );
                                    (*(*tok).pb).bpos += 3 as ::core::ffi::c_int;
                                    *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                                        '\0' as i32 as ::core::ffi::c_char;
                                } else {
                                    /* Got a high surrogate without another sequence following
                                     * it.  Put a replacement char in for the hi surrogate
                                     * and pretend we finished.
                                     */
                                    printbuf_memappend(
                                        
                                        (*tok).pb as *mut printbuf,
                                        &raw mut utf8_replacement_char as *mut ::core::ffi::c_uchar
                                            as *mut ::core::ffi::c_char,
                                        3 as ::core::ffi::c_int,
                                    );
                                }
                            } else if (*tok).ucs_char & 0xfc00 as ::core::ffi::c_uint
                                == 0xdc00 as ::core::ffi::c_uint
                            {
                                /* Got a low surrogate not preceded by a high */
                                if (*(*tok).pb).size - (*(*tok).pb).bpos > 3 as ::core::ffi::c_int {
                                    memcpy(
                                        (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                            as *mut ::core::ffi::c_void,
                                        &raw mut utf8_replacement_char as *mut ::core::ffi::c_uchar
                                            as *mut ::core::ffi::c_char
                                            as *const ::core::ffi::c_void,
                                        3 as size_t,
                                    );
                                    (*(*tok).pb).bpos += 3 as ::core::ffi::c_int;
                                    *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                                        '\0' as i32 as ::core::ffi::c_char;
                                } else {
                                    printbuf_memappend(
                                        
                                        (*tok).pb as *mut printbuf,
                                        &raw mut utf8_replacement_char as *mut ::core::ffi::c_uchar
                                            as *mut ::core::ffi::c_char,
                                        3 as ::core::ffi::c_int,
                                    );
                                }
                            } else if (*tok).ucs_char
                                < 0x10000 as ::core::ffi::c_int as ::core::ffi::c_uint
                            {
                                unescaped_utf[0 as ::core::ffi::c_int as usize] = (0xe0
                                    as ::core::ffi::c_uint
                                    | (*tok).ucs_char >> 12 as ::core::ffi::c_int)
                                    as ::core::ffi::c_uchar;
                                unescaped_utf[1 as ::core::ffi::c_int as usize] = (0x80
                                    as ::core::ffi::c_uint
                                    | (*tok).ucs_char >> 6 as ::core::ffi::c_int
                                        & 0x3f as ::core::ffi::c_uint)
                                    as ::core::ffi::c_uchar;
                                unescaped_utf[2 as ::core::ffi::c_int as usize] = (0x80
                                    as ::core::ffi::c_uint
                                    | (*tok).ucs_char & 0x3f as ::core::ffi::c_uint)
                                    as ::core::ffi::c_uchar;
                                if (*(*tok).pb).size - (*(*tok).pb).bpos > 3 as ::core::ffi::c_int {
                                    memcpy(
                                        (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                            as *mut ::core::ffi::c_void,
                                        &raw mut unescaped_utf as *mut ::core::ffi::c_uchar
                                            as *mut ::core::ffi::c_char
                                            as *const ::core::ffi::c_void,
                                        3 as size_t,
                                    );
                                    (*(*tok).pb).bpos += 3 as ::core::ffi::c_int;
                                    *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                                        '\0' as i32 as ::core::ffi::c_char;
                                } else {
                                    printbuf_memappend(
                                        
                                        (*tok).pb as *mut printbuf,
                                        &raw mut unescaped_utf as *mut ::core::ffi::c_uchar
                                            as *mut ::core::ffi::c_char,
                                        3 as ::core::ffi::c_int,
                                    );
                                }
                            } else if (*tok).ucs_char
                                < 0x110000 as ::core::ffi::c_int as ::core::ffi::c_uint
                            {
                                unescaped_utf[0 as ::core::ffi::c_int as usize] = (0xf0
                                    as ::core::ffi::c_uint
                                    | (*tok).ucs_char >> 18 as ::core::ffi::c_int
                                        & 0x7 as ::core::ffi::c_uint)
                                    as ::core::ffi::c_uchar;
                                unescaped_utf[1 as ::core::ffi::c_int as usize] = (0x80
                                    as ::core::ffi::c_uint
                                    | (*tok).ucs_char >> 12 as ::core::ffi::c_int
                                        & 0x3f as ::core::ffi::c_uint)
                                    as ::core::ffi::c_uchar;
                                unescaped_utf[2 as ::core::ffi::c_int as usize] = (0x80
                                    as ::core::ffi::c_uint
                                    | (*tok).ucs_char >> 6 as ::core::ffi::c_int
                                        & 0x3f as ::core::ffi::c_uint)
                                    as ::core::ffi::c_uchar;
                                unescaped_utf[3 as ::core::ffi::c_int as usize] = (0x80
                                    as ::core::ffi::c_uint
                                    | (*tok).ucs_char & 0x3f as ::core::ffi::c_uint)
                                    as ::core::ffi::c_uchar;
                                if (*(*tok).pb).size - (*(*tok).pb).bpos > 4 as ::core::ffi::c_int {
                                    memcpy(
                                        (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                            as *mut ::core::ffi::c_void,
                                        &raw mut unescaped_utf as *mut ::core::ffi::c_uchar
                                            as *mut ::core::ffi::c_char
                                            as *const ::core::ffi::c_void,
                                        4 as size_t,
                                    );
                                    (*(*tok).pb).bpos += 4 as ::core::ffi::c_int;
                                    *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                                        '\0' as i32 as ::core::ffi::c_char;
                                } else {
                                    printbuf_memappend(
                                        
                                        (*tok).pb as *mut printbuf,
                                        &raw mut unescaped_utf as *mut ::core::ffi::c_uchar
                                            as *mut ::core::ffi::c_char,
                                        4 as ::core::ffi::c_int,
                                    );
                                }
                            } else if (*(*tok).pb).size - (*(*tok).pb).bpos
                                > 3 as ::core::ffi::c_int
                            {
                                /* Don't know what we got--insert the replacement char */
                                memcpy(
                                    (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                        as *mut ::core::ffi::c_void,
                                    &raw mut utf8_replacement_char as *mut ::core::ffi::c_uchar
                                        as *mut ::core::ffi::c_char
                                        as *const ::core::ffi::c_void,
                                    3 as size_t,
                                );
                                (*(*tok).pb).bpos += 3 as ::core::ffi::c_int;
                                *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                                    '\0' as i32 as ::core::ffi::c_char;
                            } else {
                                /* Don't know what we got--insert the replacement char */
                                printbuf_memappend(
                                    
                                    (*tok).pb as *mut printbuf,
                                    &raw mut utf8_replacement_char as *mut ::core::ffi::c_uchar
                                        as *mut ::core::ffi::c_char,
                                    3 as ::core::ffi::c_int,
                                );
                            }
                            (*(*tok).stack.offset((*tok).depth as isize)).state =
                                (*(*tok).stack.offset((*tok).depth as isize)).saved_state;
                            break;
                        } else {
                            str = str.offset(1);
                            (*tok).char_offset += 1;
                            if !(c == 0
                                || (if (*tok).char_offset == len {
                                    (if (*tok).depth == 0 as ::core::ffi::c_int
                                        && (*(*tok).stack.offset((*tok).depth as isize)).state
                                            as ::core::ffi::c_uint
                                            == crate::src::json_tokener::json_tokener_state_eatws as ::core::ffi::c_int
                                                as ::core::ffi::c_uint
                                        && (*(*tok).stack.offset((*tok).depth as isize)).saved_state
                                            as ::core::ffi::c_uint
                                            == crate::src::json_tokener::json_tokener_state_finish as ::core::ffi::c_int
                                                as ::core::ffi::c_uint
                                    {
                                        (*tok).err = crate::src::json_tokener::json_tokener_success;
                                        0 as ::core::ffi::c_int
                                    } else {
                                        (*tok).err = crate::src::json_tokener::json_tokener_continue;
                                        0 as ::core::ffi::c_int
                                    })
                                } else {
                                    c = *str;
                                    1 as ::core::ffi::c_int
                                }) == 0)
                            {
                                continue;
                            }
                            if got_hi_surrogate != 0 {
                                /* Clean up any pending chars */
                                if (*(*tok).pb).size - (*(*tok).pb).bpos > 3 as ::core::ffi::c_int {
                                    memcpy(
                                        (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                            as *mut ::core::ffi::c_void,
                                        &raw mut utf8_replacement_char as *mut ::core::ffi::c_uchar
                                            as *mut ::core::ffi::c_char
                                            as *const ::core::ffi::c_void,
                                        3 as size_t,
                                    );
                                    (*(*tok).pb).bpos += 3 as ::core::ffi::c_int;
                                    *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                                        '\0' as i32 as ::core::ffi::c_char;
                                } else {
                                    /* Clean up any pending chars */
                                    printbuf_memappend(
                                        
                                        (*tok).pb as *mut printbuf,
                                        &raw mut utf8_replacement_char as *mut ::core::ffi::c_uchar
                                            as *mut ::core::ffi::c_char,
                                        3 as ::core::ffi::c_int,
                                    );
                                }
                            }
                            break 's_68;
                        }
                    } else {
                        (*tok).err = crate::src::json_tokener::json_tokener_error_parse_string;
                        break 's_68;
                    }
                }
                current_block = 14804750364725543955;
            }
            10482649921445892870 => {
                tok->ucs_char = 0;
                tok->st_pos = 0;
                (*(*tok).stack.offset((*tok).depth as isize)).state =
                    crate::src::json_tokener::json_tokener_state_escape_unicode;
                current_block = 14804750364725543955;
            }
            16382715083403891171 => {
                if c as ::core::ffi::c_int == 'b' as i32 {
                    if (*(*tok).pb).size - (*(*tok).pb).bpos > 1 as ::core::ffi::c_int {
                        memcpy(
                            (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                as *mut ::core::ffi::c_void,
                            b"\x08\0" as *const u8 as *const ::core::ffi::c_char
                                as *const ::core::ffi::c_void,
                            1 as size_t,
                        );
                        (*(*tok).pb).bpos += 1 as ::core::ffi::c_int;
                        *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                            '\0' as i32 as ::core::ffi::c_char;
                    } else {
                        printbuf_memappend(
                            
                            (*tok).pb as *mut printbuf,
                            b"\x08\0" as *const u8 as *const ::core::ffi::c_char,
                            1 as ::core::ffi::c_int,
                        );
                    }
                } else if c as ::core::ffi::c_int == 'n' as i32 {
                    if (*(*tok).pb).size - (*(*tok).pb).bpos > 1 as ::core::ffi::c_int {
                        memcpy(
                            (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                as *mut ::core::ffi::c_void,
                            b"\n\0" as *const u8 as *const ::core::ffi::c_char
                                as *const ::core::ffi::c_void,
                            1 as size_t,
                        );
                        (*(*tok).pb).bpos += 1 as ::core::ffi::c_int;
                        *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                            '\0' as i32 as ::core::ffi::c_char;
                    } else {
                        printbuf_memappend(
                            
                            (*tok).pb as *mut printbuf,
                            b"\n\0" as *const u8 as *const ::core::ffi::c_char,
                            1 as ::core::ffi::c_int,
                        );
                    }
                } else if c as ::core::ffi::c_int == 'r' as i32 {
                    if (*(*tok).pb).size - (*(*tok).pb).bpos > 1 as ::core::ffi::c_int {
                        memcpy(
                            (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                as *mut ::core::ffi::c_void,
                            b"\r\0" as *const u8 as *const ::core::ffi::c_char
                                as *const ::core::ffi::c_void,
                            1 as size_t,
                        );
                        (*(*tok).pb).bpos += 1 as ::core::ffi::c_int;
                        *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                            '\0' as i32 as ::core::ffi::c_char;
                    } else {
                        printbuf_memappend(
                            
                            (*tok).pb as *mut printbuf,
                            b"\r\0" as *const u8 as *const ::core::ffi::c_char,
                            1 as ::core::ffi::c_int,
                        );
                    }
                } else if c as ::core::ffi::c_int == 't' as i32 {
                    if (*(*tok).pb).size - (*(*tok).pb).bpos > 1 as ::core::ffi::c_int {
                        memcpy(
                            (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                as *mut ::core::ffi::c_void,
                            b"\t\0" as *const u8 as *const ::core::ffi::c_char
                                as *const ::core::ffi::c_void,
                            1 as size_t,
                        );
                        (*(*tok).pb).bpos += 1 as ::core::ffi::c_int;
                        *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                            '\0' as i32 as ::core::ffi::c_char;
                    } else {
                        printbuf_memappend(
                            
                            (*tok).pb as *mut printbuf,
                            b"\t\0" as *const u8 as *const ::core::ffi::c_char,
                            1 as ::core::ffi::c_int,
                        );
                    }
                } else if c as ::core::ffi::c_int == 'f' as i32 {
                    if (*(*tok).pb).size - (*(*tok).pb).bpos > 1 as ::core::ffi::c_int {
                        memcpy(
                            (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                as *mut ::core::ffi::c_void,
                            b"\x0C\0" as *const u8 as *const ::core::ffi::c_char
                                as *const ::core::ffi::c_void,
                            1 as size_t,
                        );
                        (*(*tok).pb).bpos += 1 as ::core::ffi::c_int;
                        *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                            '\0' as i32 as ::core::ffi::c_char;
                    } else {
                        printbuf_memappend(
                            
                            (*tok).pb as *mut printbuf,
                            b"\x0C\0" as *const u8 as *const ::core::ffi::c_char,
                            1 as ::core::ffi::c_int,
                        );
                    }
                }
                (*(*tok).stack.offset((*tok).depth as isize)).state =
                    (*(*tok).stack.offset((*tok).depth as isize)).saved_state;
                current_block = 14804750364725543955;
            }
            11715598964735866444 => {
                if (*(*tok).pb).size - (*(*tok).pb).bpos > 1 as ::core::ffi::c_int {
                    memcpy(
                        (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                            as *mut ::core::ffi::c_void,
                        &raw mut c as *const ::core::ffi::c_void,
                        1 as size_t,
                    );
                    (*(*tok).pb).bpos += 1 as ::core::ffi::c_int;
                    *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                        '\0' as i32 as ::core::ffi::c_char;
                } else {
                    printbuf_memappend((*tok).pb as *mut printbuf, &raw mut c, 1 as ::core::ffi::c_int);
                }
                (*(*tok).stack.offset((*tok).depth as isize)).state =
                    (*(*tok).stack.offset((*tok).depth as isize)).saved_state;
                current_block = 14804750364725543955;
            }
            4127803603908737533 => {
                /* Advance until we change state */
                loop {
                    if c as ::core::ffi::c_int == (*tok).quote_char as ::core::ffi::c_int {
                        if ((*(*tok).pb).size - (*(*tok).pb).bpos) as ::core::ffi::c_long
                            > str.offset_from(case_start_1) as ::core::ffi::c_long
                        {
                            memcpy(
                                (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                    as *mut ::core::ffi::c_void,
                                case_start_1 as *const ::core::ffi::c_void,
                                str.offset_from(case_start_1) as ::core::ffi::c_long as size_t,
                            );
                            (*(*tok).pb).bpos = ((*(*tok).pb).bpos as ::core::ffi::c_long
                                + str.offset_from(case_start_1) as ::core::ffi::c_long)
                                as ::core::ffi::c_int;
                            *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                                '\0' as i32 as ::core::ffi::c_char;
                        } else {
                            printbuf_memappend(
                                
                                (*tok).pb as *mut printbuf,
                                case_start_1,
                                str.offset_from(case_start_1) as ::core::ffi::c_long
                                    as ::core::ffi::c_int,
                            );
                        }
                        let ref mut fresh7 = (*(*tok).stack.offset((*tok).depth as isize)).current;
                        *fresh7 =  json_object_new_string_len((*(*tok).pb).buf, (*(*tok).pb).bpos) as *mut json_object;
                        if (*(*tok).stack.offset((*tok).depth as isize))
                            .current
                            .is_null()
                        {
                            break 's_68;
                        }
                        (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                            crate::src::json_tokener::json_tokener_state_finish;
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_eatws;
                        break;
                    } else if c as ::core::ffi::c_int == '\\' as i32 {
                        if ((*(*tok).pb).size - (*(*tok).pb).bpos) as ::core::ffi::c_long
                            > str.offset_from(case_start_1) as ::core::ffi::c_long
                        {
                            memcpy(
                                (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                    as *mut ::core::ffi::c_void,
                                case_start_1 as *const ::core::ffi::c_void,
                                str.offset_from(case_start_1) as ::core::ffi::c_long as size_t,
                            );
                            (*(*tok).pb).bpos = ((*(*tok).pb).bpos as ::core::ffi::c_long
                                + str.offset_from(case_start_1) as ::core::ffi::c_long)
                                as ::core::ffi::c_int;
                            *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                                '\0' as i32 as ::core::ffi::c_char;
                        } else {
                            printbuf_memappend(
                                
                                (*tok).pb as *mut printbuf,
                                case_start_1,
                                str.offset_from(case_start_1) as ::core::ffi::c_long
                                    as ::core::ffi::c_int,
                            );
                        }
                        (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                            crate::src::json_tokener::json_tokener_state_string;
                        (*(*tok).stack.offset((*tok).depth as isize)).state =
                            crate::src::json_tokener::json_tokener_state_string_escape;
                        break;
                    } else {
                        str = str.offset(1);
                        (*tok).char_offset += 1;
                        if !(c == 0
                            || (if (*tok).char_offset == len {
                                (if (*tok).depth == 0 as ::core::ffi::c_int
                                    && (*(*tok).stack.offset((*tok).depth as isize)).state
                                        as ::core::ffi::c_uint
                                        == crate::src::json_tokener::json_tokener_state_eatws as ::core::ffi::c_int
                                            as ::core::ffi::c_uint
                                    && (*(*tok).stack.offset((*tok).depth as isize)).saved_state
                                        as ::core::ffi::c_uint
                                        == crate::src::json_tokener::json_tokener_state_finish as ::core::ffi::c_int
                                            as ::core::ffi::c_uint
                                {
                                    (*tok).err = crate::src::json_tokener::json_tokener_success;
                                    0 as ::core::ffi::c_int
                                } else {
                                    (*tok).err = crate::src::json_tokener::json_tokener_continue;
                                    0 as ::core::ffi::c_int
                                })
                            } else {
                                c = *str;
                                1 as ::core::ffi::c_int
                            }) == 0)
                        {
                            continue;
                        }
                        if ((*(*tok).pb).size - (*(*tok).pb).bpos) as ::core::ffi::c_long
                            > str.offset_from(case_start_1) as ::core::ffi::c_long
                        {
                            memcpy(
                                (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                    as *mut ::core::ffi::c_void,
                                case_start_1 as *const ::core::ffi::c_void,
                                str.offset_from(case_start_1) as ::core::ffi::c_long as size_t,
                            );
                            (*(*tok).pb).bpos = ((*(*tok).pb).bpos as ::core::ffi::c_long
                                + str.offset_from(case_start_1) as ::core::ffi::c_long)
                                as ::core::ffi::c_int;
                            *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                                '\0' as i32 as ::core::ffi::c_char;
                        } else {
                            printbuf_memappend(
                                
                                (*tok).pb as *mut printbuf,
                                case_start_1,
                                str.offset_from(case_start_1) as ::core::ffi::c_long
                                    as ::core::ffi::c_int,
                            );
                        }
                        break 's_68;
                    }
                }
                current_block = 14804750364725543955;
            }
            15321816652064063775 => {
                /* Advance until we change state */
                while c as ::core::ffi::c_int != '\n' as i32 {
                    str = str.offset(1);
                    (*tok).char_offset += 1;
                    if !(c == 0
                        || (if (*tok).char_offset == len {
                            (if (*tok).depth == 0 as ::core::ffi::c_int
                                && (*(*tok).stack.offset((*tok).depth as isize)).state
                                    as ::core::ffi::c_uint
                                    == crate::src::json_tokener::json_tokener_state_eatws as ::core::ffi::c_int
                                        as ::core::ffi::c_uint
                                && (*(*tok).stack.offset((*tok).depth as isize)).saved_state
                                    as ::core::ffi::c_uint
                                    == crate::src::json_tokener::json_tokener_state_finish as ::core::ffi::c_int
                                        as ::core::ffi::c_uint
                            {
                                (*tok).err = crate::src::json_tokener::json_tokener_success;
                                0 as ::core::ffi::c_int
                            } else {
                                (*tok).err = crate::src::json_tokener::json_tokener_continue;
                                0 as ::core::ffi::c_int
                            })
                        } else {
                            c = *str;
                            1 as ::core::ffi::c_int
                        }) == 0)
                    {
                        continue;
                    }
                    if ((*(*tok).pb).size - (*(*tok).pb).bpos) as ::core::ffi::c_long
                        > str.offset_from(case_start_0) as ::core::ffi::c_long
                    {
                        memcpy(
                            (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                as *mut ::core::ffi::c_void,
                            case_start_0 as *const ::core::ffi::c_void,
                            str.offset_from(case_start_0) as ::core::ffi::c_long as size_t,
                        );
                        (*(*tok).pb).bpos = ((*(*tok).pb).bpos as ::core::ffi::c_long
                            + str.offset_from(case_start_0) as ::core::ffi::c_long)
                            as ::core::ffi::c_int;
                        *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                            '\0' as i32 as ::core::ffi::c_char;
                    } else {
                        printbuf_memappend(
                            
                            (*tok).pb as *mut printbuf,
                            case_start_0,
                            str.offset_from(case_start_0) as ::core::ffi::c_long
                                as ::core::ffi::c_int,
                        );
                    }
                    break 's_68;
                }
                if ((*(*tok).pb).size - (*(*tok).pb).bpos) as ::core::ffi::c_long
                    > str.offset_from(case_start_0) as ::core::ffi::c_long
                {
                    memcpy(
                        (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                            as *mut ::core::ffi::c_void,
                        case_start_0 as *const ::core::ffi::c_void,
                        str.offset_from(case_start_0) as ::core::ffi::c_long as size_t,
                    );
                    (*(*tok).pb).bpos = ((*(*tok).pb).bpos as ::core::ffi::c_long
                        + str.offset_from(case_start_0) as ::core::ffi::c_long)
                        as ::core::ffi::c_int;
                    *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                        '\0' as i32 as ::core::ffi::c_char;
                } else {
                    printbuf_memappend(
                        
                        (*tok).pb as *mut printbuf,
                        case_start_0,
                        str.offset_from(case_start_0) as ::core::ffi::c_long as ::core::ffi::c_int,
                    );
                }
                (*(*tok).stack.offset((*tok).depth as isize)).state = crate::src::json_tokener::json_tokener_state_eatws;
                current_block = 14804750364725543955;
            }
            14652688882591975137 => {
                /* Advance until we change state */
                while c as ::core::ffi::c_int != '*' as i32 {
                    str = str.offset(1);
                    (*tok).char_offset += 1;
                    if !(c == 0
                        || (if (*tok).char_offset == len {
                            (if (*tok).depth == 0 as ::core::ffi::c_int
                                && (*(*tok).stack.offset((*tok).depth as isize)).state
                                    as ::core::ffi::c_uint
                                    == crate::src::json_tokener::json_tokener_state_eatws as ::core::ffi::c_int
                                        as ::core::ffi::c_uint
                                && (*(*tok).stack.offset((*tok).depth as isize)).saved_state
                                    as ::core::ffi::c_uint
                                    == crate::src::json_tokener::json_tokener_state_finish as ::core::ffi::c_int
                                        as ::core::ffi::c_uint
                            {
                                (*tok).err = crate::src::json_tokener::json_tokener_success;
                                0 as ::core::ffi::c_int
                            } else {
                                (*tok).err = crate::src::json_tokener::json_tokener_continue;
                                0 as ::core::ffi::c_int
                            })
                        } else {
                            c = *str;
                            1 as ::core::ffi::c_int
                        }) == 0)
                    {
                        continue;
                    }
                    if ((*(*tok).pb).size - (*(*tok).pb).bpos) as ::core::ffi::c_long
                        > str.offset_from(case_start) as ::core::ffi::c_long
                    {
                        memcpy(
                            (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                                as *mut ::core::ffi::c_void,
                            case_start as *const ::core::ffi::c_void,
                            str.offset_from(case_start) as ::core::ffi::c_long as size_t,
                        );
                        (*(*tok).pb).bpos = ((*(*tok).pb).bpos as ::core::ffi::c_long
                            + str.offset_from(case_start) as ::core::ffi::c_long)
                            as ::core::ffi::c_int;
                        *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                            '\0' as i32 as ::core::ffi::c_char;
                    } else {
                        printbuf_memappend(
                            
                            (*tok).pb as *mut printbuf,
                            case_start,
                            str.offset_from(case_start) as ::core::ffi::c_long
                                as ::core::ffi::c_int,
                        );
                    }
                    break 's_68;
                }
                if ((*(*tok).pb).size - (*(*tok).pb).bpos) as ::core::ffi::c_long
                    > str
                        .offset(1 as ::core::ffi::c_int as isize)
                        .offset_from(case_start) as ::core::ffi::c_long
                {
                    memcpy(
                        (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                            as *mut ::core::ffi::c_void,
                        case_start as *const ::core::ffi::c_void,
                        str.offset(1 as ::core::ffi::c_int as isize)
                            .offset_from(case_start) as ::core::ffi::c_long
                            as size_t,
                    );
                    (*(*tok).pb).bpos = ((*(*tok).pb).bpos as ::core::ffi::c_long
                        + str
                            .offset(1 as ::core::ffi::c_int as isize)
                            .offset_from(case_start)
                            as ::core::ffi::c_long)
                        as ::core::ffi::c_int;
                    *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                        '\0' as i32 as ::core::ffi::c_char;
                } else {
                    printbuf_memappend(
                        
                        (*tok).pb as *mut printbuf,
                        case_start,
                        str.offset(1 as ::core::ffi::c_int as isize)
                            .offset_from(case_start) as ::core::ffi::c_long
                            as ::core::ffi::c_int,
                    );
                }
                (*(*tok).stack.offset((*tok).depth as isize)).state =
                    crate::src::json_tokener::json_tokener_state_comment_end;
                current_block = 14804750364725543955;
            }
            14155412868135599428 => {
                if c as ::core::ffi::c_int == '/' as i32 {
                    (*(*tok).stack.offset((*tok).depth as isize)).state =
                        crate::src::json_tokener::json_tokener_state_comment_eol;
                } else {
                    (*tok).err = crate::src::json_tokener::json_tokener_error_parse_comment;
                    break;
                }
                current_block = 6528931666172833996;
            }
            10520667372580636250 => {
                (*(*tok).stack.offset((*tok).depth as isize)).state = crate::src::json_tokener::json_tokener_state_string;
                printbuf_reset((*tok).pb as *mut printbuf);
                (*tok).quote_char = c;
                current_block = 14804750364725543955;
            }
            7381833562023054431 => {
                (*tok).err = crate::src::json_tokener::json_tokener_error_parse_unexpected;
                break;
            }
            2904036176499606090 => {
                (*(*tok).stack.offset((*tok).depth as isize)).state = crate::src::json_tokener::json_tokener_state_comment;
                current_block = 6528931666172833996;
            }
            10441871917347885951 => {
                (*tok).err = crate::src::json_tokener::json_tokener_error_parse_string;
                break;
            }
            10531606853991144752 => {
                (*tok).err = crate::src::json_tokener::json_tokener_error_parse_object_key_sep;
                break;
            }
            11211850645214766980 => {
                (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                    crate::src::json_tokener::json_tokener_state_finish;
                (*(*tok).stack.offset((*tok).depth as isize)).state = crate::src::json_tokener::json_tokener_state_eatws;
                current_block = 14804750364725543955;
            }
            18339326955861451691 => {
                (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                    crate::src::json_tokener::json_tokener_state_object_value;
                (*(*tok).stack.offset((*tok).depth as isize)).state = crate::src::json_tokener::json_tokener_state_eatws;
                current_block = 14804750364725543955;
            }
            721385680381463314 => {
                (*tok).err = crate::src::json_tokener::json_tokener_error_parse_unexpected;
                break;
            }
            8258632986558375165 => {
                (*(*tok).stack.offset((*tok).depth as isize)).saved_state =
                    crate::src::json_tokener::json_tokener_state_finish;
                (*(*tok).stack.offset((*tok).depth as isize)).state = crate::src::json_tokener::json_tokener_state_eatws;
                current_block = 14804750364725543955;
            }
            15447629348493591490 => {
                (*tok).st_pos += 1;
                current_block = 14804750364725543955;
            }
            3871889238474132049 => {
                (*tok).st_pos += 1;
                current_block = 14804750364725543955;
            }
            _ => {}
        }
        match current_block {
            6528931666172833996 => {
                if (*(*tok).pb).size - (*(*tok).pb).bpos > 1 as ::core::ffi::c_int {
                    memcpy(
                        (*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize)
                            as *mut ::core::ffi::c_void,
                        &raw mut c as *const ::core::ffi::c_void,
                        1 as size_t,
                    );
                    (*(*tok).pb).bpos += 1 as ::core::ffi::c_int;
                    *(*(*tok).pb).buf.offset((*(*tok).pb).bpos as isize) =
                        '\0' as i32 as ::core::ffi::c_char;
                } else {
                    printbuf_memappend((*tok).pb as *mut printbuf, &raw mut c, 1 as ::core::ffi::c_int);
                }
            }
            _ => {}
        }
        str = str.offset(1);
        (*tok).char_offset += 1;
        if c == 0 {
            break;
        }
    }

    if c as ::core::ffi::c_int != 0
        && (*(*tok).stack.offset((*tok).depth as isize)).state as ::core::ffi::c_uint
            == crate::src::json_tokener::json_tokener_state_finish as ::core::ffi::c_int as ::core::ffi::c_uint
        && (*tok).depth == 0 as ::core::ffi::c_int
        && (*tok).flags & crate::src::json_tokener::JSON_TOKENER_STRICT != 0
    {
        /* unexpected char after JSON data */
        (*tok).err = crate::src::json_tokener::json_tokener_error_parse_unexpected;
    }
    if c == 0 { /* We hit an eof char (0) */
        if (*(*tok).stack.offset((*tok).depth as isize)).state as ::core::ffi::c_uint
            != crate::src::json_tokener::json_tokener_state_finish as ::core::ffi::c_int as ::core::ffi::c_uint
            && (*(*tok).stack.offset((*tok).depth as isize)).saved_state as ::core::ffi::c_uint
                != crate::src::json_tokener::json_tokener_state_finish as ::core::ffi::c_int as ::core::ffi::c_uint
        {
            (*tok).err = crate::src::json_tokener::json_tokener_error_parse_eof;
        }
    }
    uselocale(oldlocale);
    freelocale(newloc);
    if (*tok).err as ::core::ffi::c_uint
        == crate::src::json_tokener::json_tokener_success as ::core::ffi::c_int as ::core::ffi::c_uint
    {
        let mut ret: *mut json_object =
            
            json_object_get((*(*tok).stack.offset((*tok).depth as isize)).current as
    *mut json_object) as
    *mut json_object
                as *mut json_object;
        let mut ii: ::core::ffi::c_int = 0;

        /* Partially reset, so we parse additional objects on subsequent calls. */
        ii = (*tok).depth;
        while ii >= 0 as ::core::ffi::c_int {
            json_tokener_reset_level(tok, ii);
            ii -= 1;
        }
        return ret as *mut json_object;
    }
    return ::core::ptr::null_mut::<json_object>();
}