fn __zero_std_parse_is_ascii_digit(value: Span<u8>) -> Bool {
    return std.mem.len(value) > 0 && value[0] >= 48_u8 && value[0] <= 57_u8
}

fn __zero_std_parse_is_ascii_alpha(value: Span<u8>) -> Bool {
    if std.mem.len(value) == 0 {
        return false
    }
    let byte: u8 = value[0]
    return (byte >= 65_u8 && byte <= 90_u8) || (byte >= 97_u8 && byte <= 122_u8)
}

fn __zero_std_parse_is_identifier_start(value: Span<u8>) -> Bool {
    if std.mem.len(value) == 0 {
        return false
    }
    let byte: u8 = value[0]
    return __zero_std_parse_is_ascii_alpha(value) || byte == 95_u8
}

fn __zero_std_parse_is_whitespace(value: Span<u8>) -> Bool {
    if std.mem.len(value) == 0 {
        return false
    }
    let byte: u8 = value[0]
    return byte == 32_u8 || byte == 9_u8 || byte == 10_u8 || byte == 13_u8
}

fn __zero_std_parse_scan_digits(value: Span<u8>) -> usize {
    var index: usize = 0
    while index < std.mem.len(value) && value[index] >= 48_u8 && value[index] <= 57_u8 {
        index = index + 1
    }
    return index
}

fn __zero_std_parse_scan_whitespace(value: Span<u8>) -> usize {
    var index: usize = 0
    while index < std.mem.len(value) && (value[index] == 32_u8 || value[index] == 9_u8 || value[index] == 10_u8 || value[index] == 13_u8) {
        index = index + 1
    }
    return index
}

fn __zero_std_parse_identifier_byte(byte: u8) -> Bool {
    return (byte >= 65_u8 && byte <= 90_u8) || (byte >= 97_u8 && byte <= 122_u8) || (byte >= 48_u8 && byte <= 57_u8) || byte == 95_u8
}

fn __zero_std_parse_scan_identifier(value: Span<u8>) -> usize {
    if !__zero_std_parse_is_identifier_start(value) {
        return 0
    }
    var index: usize = 1
    while index < std.mem.len(value) && __zero_std_parse_identifier_byte(value[index]) {
        index = index + 1
    }
    return index
}

fn __zero_std_parse_scan_until_byte(value: Span<u8>, byte: u8) -> usize {
    var index: usize = 0
    while index < std.mem.len(value) {
        if value[index] == byte {
            return index
        }
        index = index + 1
    }
    return std.mem.len(value)
}

fn __zero_std_parse_token_ascii(value: Span<u8>) -> Span<u8> {
    let start: usize = __zero_std_parse_scan_whitespace(value)
    var end: usize = start
    while end < std.mem.len(value) && !(value[end] == 32_u8 || value[end] == 9_u8 || value[end] == 10_u8 || value[end] == 13_u8) {
        end = end + 1
    }
    return value[start..end]
}

fn __zero_std_parse_parse_u32_max(value: Span<u8>, max: u32) -> Maybe<u32> {
    if std.mem.len(value) == 0 {
        return null
    }
    var index: usize = 0
    var total: u32 = 0
    while index < std.mem.len(value) {
        let byte: u8 = value[index]
        if byte < 48_u8 || byte > 57_u8 {
            return null
        }
        let digit: u32 = (byte - 48_u8) as u32
        if total > (max - digit) / 10_u32 {
            return null
        }
        total = total * 10_u32 + digit
        index = index + 1
    }
    return total
}

fn __zero_std_parse_digit_value(byte: u8) -> Maybe<u32> {
    if byte >= 48_u8 && byte <= 57_u8 {
        return (byte - 48_u8) as u32
    }
    if byte >= 65_u8 && byte <= 90_u8 {
        return ((byte - 65_u8) as u32) + 10_u32
    }
    if byte >= 97_u8 && byte <= 122_u8 {
        return ((byte - 97_u8) as u32) + 10_u32
    }
    return null
}

fn __zero_std_parse_parse_u32_base_max(value: Span<u8>, base: u32, max: u32) -> Maybe<u32> {
    if std.mem.len(value) == 0 || base < 2_u32 || base > 36_u32 {
        return null
    }
    var index: usize = 0
    var total: u32 = 0
    while index < std.mem.len(value) {
        let digit: Maybe<u32> = __zero_std_parse_digit_value(value[index])
        if !digit.has || digit.value >= base {
            return null
        }
        if total > (max - digit.value) / base {
            return null
        }
        total = total * base + digit.value
        index = index + 1
    }
    return total
}

fn __zero_std_parse_parse_u64_base_max(value: Span<u8>, base: u32, max: u64) -> Maybe<u64> {
    if std.mem.len(value) == 0 || base < 2_u32 || base > 36_u32 {
        return null
    }
    var index: usize = 0
    var total: u64 = 0_u64
    let u64_base: u64 = base as u64
    while index < std.mem.len(value) {
        let digit: Maybe<u32> = __zero_std_parse_digit_value(value[index])
        if !digit.has || digit.value >= base {
            return null
        }
        let u64_digit: u64 = digit.value as u64
        if total > (max - u64_digit) / u64_base {
            return null
        }
        total = total * u64_base + u64_digit
        index = index + 1
    }
    return total
}

fn __zero_std_parse_parse_u32_base(value: Span<u8>, base: u32) -> Maybe<u32> {
    return __zero_std_parse_parse_u32_base_max(value, base, 4294967295_u32)
}

fn __zero_std_parse_parse_u64_base(value: Span<u8>, base: u32) -> Maybe<u64> {
    return __zero_std_parse_parse_u64_base_max(value, base, 18446744073709551615_u64)
}

fn __zero_std_parse_parse_usize_base(value: Span<u8>, base: u32) -> Maybe<usize> {
    if std.mem.len(value) == 0 || base < 2_u32 || base > 36_u32 {
        return null
    }
    var index: usize = 0
    var total: usize = 0
    let max: usize = 18446744073709551615
    let usize_base: usize = base as usize
    while index < std.mem.len(value) {
        let digit: Maybe<u32> = __zero_std_parse_digit_value(value[index])
        if !digit.has || digit.value >= base {
            return null
        }
        let usize_digit: usize = digit.value as usize
        if total > (max - usize_digit) / usize_base {
            return null
        }
        total = total * usize_base + usize_digit
        index = index + 1
    }
    return total
}

fn __zero_std_parse_parse_i64_base(value: Span<u8>, base: u32) -> Maybe<i64> {
    if std.mem.len(value) == 0 {
        return null
    }
    var start: usize = 0
    var negative: Bool = false
    if value[0] == 45_u8 {
        negative = true
        start = 1
    } else if value[0] == 43_u8 {
        start = 1
    }
    if start == std.mem.len(value) {
        return null
    }
    let limit: u64 = 9223372036854775808_u64
    let parsed: Maybe<u64> = __zero_std_parse_parse_u64_base_max(value[start..], base, limit)
    if !parsed.has {
        return null
    }
    if negative {
        if parsed.value == limit {
            return 0_i64 - 9223372036854775807_i64 - 1_i64
        }
        return 0_i64 - (parsed.value as i64)
    }
    if parsed.value > 9223372036854775807_u64 {
        return null
    }
    return parsed.value as i64
}

fn __zero_std_parse_parse_i32_base(value: Span<u8>, base: u32) -> Maybe<i32> {
    if std.mem.len(value) == 0 {
        return null
    }
    var start: usize = 0
    var negative: Bool = false
    if value[0] == 45_u8 {
        negative = true
        start = 1
    } else if value[0] == 43_u8 {
        start = 1
    }
    if start == std.mem.len(value) {
        return null
    }
    let limit: u32 = 2147483648_u32
    let parsed: Maybe<u32> = __zero_std_parse_parse_u32_base_max(value[start..], base, limit)
    if !parsed.has {
        return null
    }
    if negative {
        if parsed.value == limit {
            return 0 - 2147483647 - 1
        }
        return 0 - (parsed.value as i32)
    }
    if parsed.value > 2147483647_u32 {
        return null
    }
    return parsed.value as i32
}

fn __zero_std_parse_prefixed_base(value: Span<u8>) -> u32 {
    if std.mem.len(value) >= 2 && value[0] == 48_u8 {
        if value[1] == 120_u8 || value[1] == 88_u8 {
            return 16_u32
        }
        if value[1] == 98_u8 || value[1] == 66_u8 {
            return 2_u32
        }
        if value[1] == 111_u8 || value[1] == 79_u8 {
            return 8_u32
        }
    }
    return 10_u32
}

fn __zero_std_parse_prefixed_digits(value: Span<u8>) -> Span<u8> {
    if std.mem.len(value) >= 2 && value[0] == 48_u8 {
        if value[1] == 120_u8 || value[1] == 88_u8 || (value[1] == 98_u8 || value[1] == 66_u8) || (value[1] == 111_u8 || value[1] == 79_u8) {
            return value[2..]
        }
    }
    return value
}

fn __zero_std_parse_parse_u32_prefix(value: Span<u8>) -> Maybe<u32> {
    let base: u32 = __zero_std_parse_prefixed_base(value)
    let digits: Span<u8> = __zero_std_parse_prefixed_digits(value)
    return __zero_std_parse_parse_u32_base(digits, base)
}

fn __zero_std_parse_parse_u64_prefix(value: Span<u8>) -> Maybe<u64> {
    let base: u32 = __zero_std_parse_prefixed_base(value)
    let digits: Span<u8> = __zero_std_parse_prefixed_digits(value)
    return __zero_std_parse_parse_u64_base(digits, base)
}

fn __zero_std_parse_parse_usize_prefix(value: Span<u8>) -> Maybe<usize> {
    let base: u32 = __zero_std_parse_prefixed_base(value)
    let digits: Span<u8> = __zero_std_parse_prefixed_digits(value)
    return __zero_std_parse_parse_usize_base(digits, base)
}

fn __zero_std_parse_parse_i64_prefix(value: Span<u8>) -> Maybe<i64> {
    if std.mem.len(value) == 0 {
        return null
    }
    var start: usize = 0
    var negative: Bool = false
    if value[0] == 45_u8 || value[0] == 43_u8 {
        negative = value[0] == 45_u8
        start = 1
    }
    if start == std.mem.len(value) {
        return null
    }
    let base: u32 = __zero_std_parse_prefixed_base(value[start..])
    let digits: Span<u8> = __zero_std_parse_prefixed_digits(value[start..])
    let limit: u64 = 9223372036854775808_u64
    let parsed: Maybe<u64> = __zero_std_parse_parse_u64_base_max(digits, base, limit)
    if !parsed.has {
        return null
    }
    if negative {
        if parsed.value == limit {
            return 0_i64 - 9223372036854775807_i64 - 1_i64
        }
        return 0_i64 - (parsed.value as i64)
    }
    if parsed.value > 9223372036854775807_u64 {
        return null
    }
    return parsed.value as i64
}

fn __zero_std_parse_parse_i32_prefix(value: Span<u8>) -> Maybe<i32> {
    if std.mem.len(value) == 0 {
        return null
    }
    var start: usize = 0
    var negative: Bool = false
    if value[0] == 45_u8 || value[0] == 43_u8 {
        negative = value[0] == 45_u8
        start = 1
    }
    if start == std.mem.len(value) {
        return null
    }
    let base: u32 = __zero_std_parse_prefixed_base(value[start..])
    let digits: Span<u8> = __zero_std_parse_prefixed_digits(value[start..])
    let limit: u32 = 2147483648_u32
    let parsed: Maybe<u32> = __zero_std_parse_parse_u32_base_max(digits, base, limit)
    if !parsed.has {
        return null
    }
    if negative {
        if parsed.value == limit {
            return 0 - 2147483647 - 1
        }
        return 0 - (parsed.value as i32)
    }
    if parsed.value > 2147483647_u32 {
        return null
    }
    return parsed.value as i32
}

fn __zero_std_parse_parse_u8(value: Span<u8>) -> Maybe<u8> {
    let parsed: Maybe<u32> = __zero_std_parse_parse_u32_max(value, 255_u32)
    if parsed.has {
        return parsed.value as u8
    }
    return null
}

fn __zero_std_parse_parse_u16(value: Span<u8>) -> Maybe<u16> {
    let parsed: Maybe<u32> = __zero_std_parse_parse_u32_max(value, 65535_u32)
    if parsed.has {
        return parsed.value as u16
    }
    return null
}

fn __zero_std_parse_parse_u32(value: Span<u8>) -> Maybe<u32> {
    return __zero_std_parse_parse_u32_max(value, 4294967295_u32)
}

fn __zero_std_parse_parse_u64(value: Span<u8>) -> Maybe<u64> {
    return __zero_std_parse_parse_u64_base(value, 10_u32)
}

fn __zero_std_parse_parse_usize(value: Span<u8>) -> Maybe<usize> {
    if std.mem.len(value) == 0 {
        return null
    }
    var index: usize = 0
    var total: usize = 0
    let max: usize = 18446744073709551615
    while index < std.mem.len(value) {
        let byte: u8 = value[index]
        if byte < 48_u8 || byte > 57_u8 {
            return null
        }
        let digit: usize = (byte - 48_u8) as usize
        if total > (max - digit) / 10 {
            return null
        }
        total = total * 10 + digit
        index = index + 1
    }
    return total
}

fn __zero_std_parse_parse_i64(value: Span<u8>) -> Maybe<i64> {
    return __zero_std_parse_parse_i64_base(value, 10_u32)
}

fn __zero_std_parse_parse_i32(value: Span<u8>) -> Maybe<i32> {
    if std.mem.len(value) == 0 {
        return null
    }
    var start: usize = 0
    var negative: Bool = false
    if value[0] == 45_u8 {
        negative = true
        start = 1
    } else if value[0] == 43_u8 {
        start = 1
    }
    if start == std.mem.len(value) {
        return null
    }
    let limit: u32 = 2147483648_u32
    let parsed: Maybe<u32> = __zero_std_parse_parse_u32_max(value[start..], limit)
    if !parsed.has {
        return null
    }
    if negative {
        if parsed.value == limit {
            return 0 - 2147483647 - 1
        }
        return 0 - (parsed.value as i32)
    }
    if parsed.value > 2147483647_u32 {
        return null
    }
    return parsed.value as i32
}

fn __zero_std_parse_parse_bool(value: Span<u8>) -> Maybe<Bool> {
    if std.mem.eql(value, "true") {
        return true
    }
    if std.mem.eql(value, "false") {
        return false
    }
    return null
}

fn __zero_std_parse_duration_unit_ns(value: Span<u8>) -> Maybe<u64> {
    if std.mem.eql(value, "ns") {
        return 1_u64
    }
    if std.mem.eql(value, "us") {
        return 1000_u64
    }
    if std.mem.eql(value, "ms") {
        return 1000000_u64
    }
    if std.mem.eql(value, "s") {
        return 1000000000_u64
    }
    if std.mem.eql(value, "m") {
        return 60000000000_u64
    }
    if std.mem.eql(value, "h") {
        return 3600000000000_u64
    }
    return null
}

fn __zero_std_parse_parse_duration(value: Span<u8>) -> Maybe<Duration> {
    if std.mem.len(value) == 0 {
        return null
    }
    var index: usize = 0
    var negative: Bool = false
    if value[0] == 45_u8 || value[0] == 43_u8 {
        negative = value[0] == 45_u8
        index = 1
    }
    if index == std.mem.len(value) {
        return null
    }
    var max: u64 = 9223372036854775807_u64
    if negative {
        max = 9223372036854775808_u64
    }
    var total: u64 = 0_u64
    var saw_component: Bool = false
    while index < std.mem.len(value) {
        let digit_start: usize = index
        while index < std.mem.len(value) && (value[index] >= 48_u8 && value[index] <= 57_u8) {
            index = index + 1
        }
        if digit_start == index {
            return null
        }
        let amount: Maybe<u64> = __zero_std_parse_parse_u64(value[digit_start..index])
        if !amount.has {
            return null
        }
        let unit_start: usize = index
        while index < std.mem.len(value) && (value[index] < 48_u8 || value[index] > 57_u8) {
            index = index + 1
        }
        if unit_start == index {
            return null
        }
        let multiplier: Maybe<u64> = __zero_std_parse_duration_unit_ns(value[unit_start..index])
        if !multiplier.has {
            return null
        }
        if amount.value > (max - total) / multiplier.value {
            return null
        }
        total = total + amount.value * multiplier.value
        saw_component = true
    }
    if !saw_component {
        return null
    }
    if negative {
        if total == 9223372036854775808_u64 {
            return std.time.ns(0_i64 - 9223372036854775807_i64 - 1_i64)
        }
        return std.time.ns(0_i64 - (total as i64))
    }
    return std.time.ns(total as i64)
}

fn __zero_std_parse_byte_size_multiplier(unit: Span<u8>) -> Maybe<usize> {
    if std.mem.len(unit) == 0 || std.mem.eql(unit, "B") {
        return 1_usize
    }
    if std.mem.eql(unit, "KB") {
        return 1000_usize
    }
    if std.mem.eql(unit, "MB") {
        return 1000000_usize
    }
    if std.mem.eql(unit, "GB") {
        return 1000000000_usize
    }
    if std.mem.eql(unit, "KiB") {
        return 1024_usize
    }
    if std.mem.eql(unit, "MiB") {
        return 1048576_usize
    }
    if std.mem.eql(unit, "GiB") {
        return 1073741824_usize
    }
    return null
}

fn __zero_std_parse_parse_byte_size(value: Span<u8>) -> Maybe<usize> {
    if std.mem.len(value) == 0 {
        return null
    }
    var index: usize = 0
    while index < std.mem.len(value) && (value[index] >= 48_u8 && value[index] <= 57_u8) {
        index = index + 1
    }
    if index == 0 {
        return null
    }
    let amount: Maybe<usize> = __zero_std_parse_parse_usize(value[..index])
    if !amount.has {
        return null
    }
    let multiplier: Maybe<usize> = __zero_std_parse_byte_size_multiplier(value[index..])
    if !multiplier.has {
        return null
    }
    let max: usize = 18446744073709551615
    if amount.value > max / multiplier.value {
        return null
    }
    return amount.value * multiplier.value
}