fn __zero_std_toml_validate(bytes: Span<u8>) -> Bool {
    var index: usize = 0
    while index < std.mem.len(bytes) {
        let line_end: usize = __zero_std_toml_line_end(bytes, index)
        let content_end: usize = __zero_std_toml_comment_end(bytes, index, line_end)
        let start: usize = __zero_std_toml_skip_ws(bytes, index, content_end)
        if start < content_end {
            if bytes[start] == 91_u8 {
                let table_end: Maybe<usize> = __zero_std_toml_table_end(bytes, start, content_end)
                if !table_end.has {
                    return false
                }
            } else {
                let equals: Maybe<usize> = __zero_std_toml_find_equals(bytes, start, content_end)
                if !equals.has {
                    return false
                }
                let key_end: usize = __zero_std_toml_trim_end(bytes, start, equals.value)
                let value_start: usize = __zero_std_toml_skip_ws(bytes, equals.value + 1, content_end)
                let value_end: usize = __zero_std_toml_trim_end(bytes, value_start, content_end)
                if key_end == start || value_start == value_end || !__zero_std_toml_value_valid(bytes[value_start..value_end]) {
                    return false
                }
            }
        }
        index = line_end
        if index < std.mem.len(bytes) && bytes[index] == 10_u8 {
            index = index + 1
        }
    }
    return true
}

fn __zero_std_toml_validate_bytes(bytes: Span<u8>) -> Bool {
    return __zero_std_toml_validate(bytes)
}

fn __zero_std_toml_field(bytes: Span<u8>, key: Span<u8>) -> Maybe<Span<u8>> {
    var table_start: usize = 0
    var table_end: usize = 0
    var has_table: Bool = false
    var index: usize = 0
    while index < std.mem.len(bytes) {
        let line_end: usize = __zero_std_toml_line_end(bytes, index)
        let content_end: usize = __zero_std_toml_comment_end(bytes, index, line_end)
        let start: usize = __zero_std_toml_skip_ws(bytes, index, content_end)
        if start < content_end {
            if bytes[start] == 91_u8 {
                let next_table_end: Maybe<usize> = __zero_std_toml_table_end(bytes, start, content_end)
                if !next_table_end.has {
                    return null
                }
                table_start = start + 1
                table_end = next_table_end.value
                has_table = true
            } else {
                let equals: Maybe<usize> = __zero_std_toml_find_equals(bytes, start, content_end)
                if !equals.has {
                    return null
                }
                let field_key_end: usize = __zero_std_toml_trim_end(bytes, start, equals.value)
                let value_start: usize = __zero_std_toml_skip_ws(bytes, equals.value + 1, content_end)
                let value_end: usize = __zero_std_toml_trim_end(bytes, value_start, content_end)
                var table: Span<u8> = bytes[0..0]
                if has_table {
                    table = bytes[table_start..table_end]
                }
                if __zero_std_toml_key_matches(table, bytes[start..field_key_end], key) {
                    return bytes[value_start..value_end]
                }
            }
        }
        index = line_end
        if index < std.mem.len(bytes) && bytes[index] == 10_u8 {
            index = index + 1
        }
    }
    return null
}

fn __zero_std_toml_string_decode(buffer: MutSpan<u8>, value: Span<u8>) -> Maybe<Span<u8>> {
    if std.mem.len(value) < 2 || value[0] != 34_u8 || value[std.mem.len(value) - 1] != 34_u8 {
        return null
    }
    var input: usize = 1
    var output: usize = 0
    while input + 1 < std.mem.len(value) {
        var byte: u8 = value[input]
        if byte == 92_u8 {
            input = input + 1
            if input + 1 >= std.mem.len(value) {
                return null
            }
            let escaped: u8 = value[input]
            if escaped == 34_u8 {
                byte = 34_u8
            } else if escaped == 92_u8 {
                byte = 92_u8
            } else if escaped == 110_u8 {
                byte = 10_u8
            } else if escaped == 114_u8 {
                byte = 13_u8
            } else if escaped == 116_u8 {
                byte = 9_u8
            } else {
                return null
            }
        }
        if output >= std.mem.len(buffer) {
            return null
        }
        buffer[output] = byte
        output = output + 1
        input = input + 1
    }
    return buffer[..output]
}

fn __zero_std_toml_string(buffer: MutSpan<u8>, bytes: Span<u8>, key: Span<u8>) -> Maybe<Span<u8>> {
    let raw: Maybe<Span<u8>> = __zero_std_toml_field(bytes, key)
    if !raw.has {
        return null
    }
    return __zero_std_toml_string_decode(buffer, raw.value)
}

fn __zero_std_toml_u32(bytes: Span<u8>, key: Span<u8>) -> Maybe<u32> {
    let raw: Maybe<Span<u8>> = __zero_std_toml_field(bytes, key)
    if !raw.has {
        return null
    }
    return std.parse.parseU32(raw.value)
}

fn __zero_std_toml_i32(bytes: Span<u8>, key: Span<u8>) -> Maybe<i32> {
    let raw: Maybe<Span<u8>> = __zero_std_toml_field(bytes, key)
    if !raw.has {
        return null
    }
    return std.parse.parseI32(raw.value)
}

fn __zero_std_toml_bool(bytes: Span<u8>, key: Span<u8>) -> Maybe<Bool> {
    let raw: Maybe<Span<u8>> = __zero_std_toml_field(bytes, key)
    if !raw.has {
        return null
    }
    return std.parse.parseBool(raw.value)
}

fn __zero_std_toml_array_count(value: Span<u8>) -> Maybe<usize> {
    if !__zero_std_toml_array_valid(value) {
        return null
    }
    var count: usize = 0
    var index: usize = 1
    let end: usize = std.mem.len(value) - 1
    while index < end {
        index = __zero_std_toml_skip_ws(value, index, end)
        if index == end {
            return count
        }
        let item_end: Maybe<usize> = __zero_std_toml_array_item_end(value, index, end)
        if !item_end.has {
            return null
        }
        count = count + 1
        index = item_end.value
        index = __zero_std_toml_skip_ws(value, index, end)
        if index < end {
            index = index + 1
        }
    }
    return count
}

fn __zero_std_toml_array_value(value: Span<u8>, ordinal: usize) -> Maybe<Span<u8>> {
    if !__zero_std_toml_array_valid(value) {
        return null
    }
    var count: usize = 0
    var index: usize = 1
    let end: usize = std.mem.len(value) - 1
    while index < end {
        index = __zero_std_toml_skip_ws(value, index, end)
        if index == end {
            return null
        }
        let item_end: Maybe<usize> = __zero_std_toml_array_item_end(value, index, end)
        if !item_end.has {
            return null
        }
        if count == ordinal {
            return value[index..item_end.value]
        }
        count = count + 1
        index = item_end.value
        index = __zero_std_toml_skip_ws(value, index, end)
        if index < end {
            index = index + 1
        }
    }
    return null
}

fn __zero_std_toml_array_string(buffer: MutSpan<u8>, value: Span<u8>, ordinal: usize) -> Maybe<Span<u8>> {
    let raw: Maybe<Span<u8>> = __zero_std_toml_array_value(value, ordinal)
    if !raw.has {
        return null
    }
    return __zero_std_toml_string_decode(buffer, raw.value)
}

fn __zero_std_toml_array_u32(value: Span<u8>, ordinal: usize) -> Maybe<u32> {
    let raw: Maybe<Span<u8>> = __zero_std_toml_array_value(value, ordinal)
    if !raw.has {
        return null
    }
    return std.parse.parseU32(raw.value)
}

fn __zero_std_toml_array_i32(value: Span<u8>, ordinal: usize) -> Maybe<i32> {
    let raw: Maybe<Span<u8>> = __zero_std_toml_array_value(value, ordinal)
    if !raw.has {
        return null
    }
    return std.parse.parseI32(raw.value)
}

fn __zero_std_toml_array_bool(value: Span<u8>, ordinal: usize) -> Maybe<Bool> {
    let raw: Maybe<Span<u8>> = __zero_std_toml_array_value(value, ordinal)
    if !raw.has {
        return null
    }
    return std.parse.parseBool(raw.value)
}

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

fn __zero_std_toml_dotted_key_valid(key: Span<u8>) -> Bool {
    if std.mem.len(key) == 0 {
        return false
    }
    var index: usize = 0
    var segment_has_byte: Bool = false
    while index < std.mem.len(key) {
        let byte: u8 = key[index]
        if byte == 46_u8 {
            if !segment_has_byte {
                return false
            }
            segment_has_byte = false
        } else if __zero_std_toml_key_byte_valid(byte) {
            segment_has_byte = true
        } else {
            return false
        }
        index = index + 1
    }
    return segment_has_byte
}

fn __zero_std_toml_write_key_value_string(buffer: MutSpan<u8>, key: Span<u8>, value: Span<u8>) -> Maybe<Span<u8>> {
    if !__zero_std_toml_dotted_key_valid(key) {
        return null
    }
    var cursor: usize = 0
    let key_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, key)
    if !key_end.has {
        return null
    }
    cursor = key_end.value
    let sep_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, " = ")
    if !sep_end.has {
        return null
    }
    cursor = sep_end.value
    let value_end: Maybe<usize> = __zero_std_toml_write_escaped_string(buffer, cursor, value)
    if !value_end.has {
        return null
    }
    cursor = value_end.value
    let line_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, "\n")
    if !line_end.has {
        return null
    }
    return buffer[..line_end.value]
}

fn __zero_std_toml_write_key_value_u32(buffer: MutSpan<u8>, key: Span<u8>, value: u32) -> Maybe<Span<u8>> {
    if !__zero_std_toml_dotted_key_valid(key) {
        return null
    }
    var cursor: usize = 0
    let key_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, key)
    if !key_end.has {
        return null
    }
    cursor = key_end.value
    let sep_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, " = ")
    if !sep_end.has {
        return null
    }
    cursor = sep_end.value
    let digits: Maybe<Span<u8>> = std.fmt.u32(buffer[cursor..], value)
    if !digits.has {
        return null
    }
    cursor = cursor + std.mem.len(digits.value)
    let line_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, "\n")
    if !line_end.has {
        return null
    }
    return buffer[..line_end.value]
}

fn __zero_std_toml_write_key_value_bool(buffer: MutSpan<u8>, key: Span<u8>, value: Bool) -> Maybe<Span<u8>> {
    if !__zero_std_toml_dotted_key_valid(key) {
        return null
    }
    var cursor: usize = 0
    let key_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, key)
    if !key_end.has {
        return null
    }
    cursor = key_end.value
    let sep_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, " = ")
    if !sep_end.has {
        return null
    }
    cursor = sep_end.value
    var value_end: Maybe<usize> = null
    if value {
        value_end = __zero_std_toml_write_span(buffer, cursor, "true")
    } else {
        value_end = __zero_std_toml_write_span(buffer, cursor, "false")
    }
    if !value_end.has {
        return null
    }
    cursor = value_end.value
    let line_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, "\n")
    if !line_end.has {
        return null
    }
    return buffer[..line_end.value]
}

fn __zero_std_toml_write_table_header(buffer: MutSpan<u8>, table: Span<u8>) -> Maybe<Span<u8>> {
    if !__zero_std_toml_dotted_key_valid(table) {
        return null
    }
    var cursor: usize = 0
    let open_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, "[")
    if !open_end.has {
        return null
    }
    cursor = open_end.value
    let table_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, table)
    if !table_end.has {
        return null
    }
    cursor = table_end.value
    let close_end: Maybe<usize> = __zero_std_toml_write_span(buffer, cursor, "]\n")
    if !close_end.has {
        return null
    }
    return buffer[..close_end.value]
}

fn __zero_std_toml_line_end(bytes: Span<u8>, start: usize) -> usize {
    var index: usize = start
    while index < std.mem.len(bytes) && bytes[index] != 10_u8 {
        index = index + 1
    }
    return index
}

fn __zero_std_toml_skip_ws(bytes: Span<u8>, start: usize, end: usize) -> usize {
    var index: usize = start
    while index < end && (bytes[index] == 32_u8 || bytes[index] == 9_u8 || bytes[index] == 13_u8) {
        index = index + 1
    }
    return index
}

fn __zero_std_toml_trim_end(bytes: Span<u8>, start: usize, end: usize) -> usize {
    var index: usize = end
    while index > start && (bytes[index - 1] == 32_u8 || bytes[index - 1] == 9_u8 || bytes[index - 1] == 13_u8) {
        index = index - 1
    }
    return index
}

fn __zero_std_toml_comment_end(bytes: Span<u8>, start: usize, end: usize) -> usize {
    var index: usize = start
    var in_string: Bool = false
    var escaped: Bool = false
    while index < end {
        let byte: u8 = bytes[index]
        if escaped {
            escaped = false
        } else if in_string && byte == 92_u8 {
            escaped = true
        } else if byte == 34_u8 {
            in_string = !in_string
        } else if !in_string && byte == 35_u8 {
            return __zero_std_toml_trim_end(bytes, start, index)
        }
        index = index + 1
    }
    return end
}

fn __zero_std_toml_find_equals(bytes: Span<u8>, start: usize, end: usize) -> Maybe<usize> {
    var index: usize = start
    var in_string: Bool = false
    var escaped: Bool = false
    while index < end {
        let byte: u8 = bytes[index]
        if escaped {
            escaped = false
        } else if in_string && byte == 92_u8 {
            escaped = true
        } else if byte == 34_u8 {
            in_string = !in_string
        } else if !in_string && byte == 61_u8 {
            return index
        }
        index = index + 1
    }
    return null
}

fn __zero_std_toml_table_end(bytes: Span<u8>, start: usize, end: usize) -> Maybe<usize> {
    if start >= end || bytes[start] != 91_u8 {
        return null
    }
    var index: usize = start + 1
    while index < end {
        if bytes[index] == 93_u8 {
            let trailing: usize = __zero_std_toml_skip_ws(bytes, index + 1, end)
            if trailing == end && index > start + 1 {
                return index
            }
            return null
        }
        index = index + 1
    }
    return null
}

fn __zero_std_toml_string_value_end(value: Span<u8>) -> Maybe<usize> {
    if std.mem.len(value) == 0 || value[0] != 34_u8 {
        return null
    }
    var index: usize = 1
    var escaped: Bool = false
    while index < std.mem.len(value) {
        let byte: u8 = value[index]
        if escaped {
            if !(byte == 34_u8 || byte == 92_u8 || byte == 110_u8 || byte == 114_u8 || byte == 116_u8) {
                return null
            }
            escaped = false
        } else if byte == 92_u8 {
            escaped = true
        } else if byte == 34_u8 {
            return index + 1
        }
        index = index + 1
    }
    return null
}

fn __zero_std_toml_array_valid(value: Span<u8>) -> Bool {
    if std.mem.len(value) < 2 || value[0] != 91_u8 || value[std.mem.len(value) - 1] != 93_u8 {
        return false
    }
    var index: usize = 1
    let end: usize = std.mem.len(value) - 1
    while index < end {
        index = __zero_std_toml_skip_ws(value, index, end)
        if index == end {
            return true
        }
        let item_end: Maybe<usize> = __zero_std_toml_array_item_end(value, index, end)
        if !item_end.has {
            return false
        }
        index = item_end.value
        index = __zero_std_toml_skip_ws(value, index, end)
        if index < end {
            if value[index] != 44_u8 {
                return false
            }
            index = index + 1
        }
    }
    return true
}

fn __zero_std_toml_array_item_end(value: Span<u8>, start: usize, end: usize) -> Maybe<usize> {
    if start >= end {
        return null
    }
    if value[start] == 34_u8 {
        let item_end: Maybe<usize> = __zero_std_toml_string_value_end(value[start..end])
        if !item_end.has {
            return null
        }
        return start + item_end.value
    }
    var index: usize = start
    while index < end && value[index] != 44_u8 {
        index = index + 1
    }
    let trimmed: usize = __zero_std_toml_trim_end(value, start, index)
    if trimmed == start {
        return null
    }
    if __zero_std_toml_value_valid(value[start..trimmed]) {
        return trimmed
    }
    return null
}

fn __zero_std_toml_value_valid(value: Span<u8>) -> Bool {
    if std.mem.len(value) == 0 {
        return false
    }
    if value[0] == 34_u8 {
        let end: Maybe<usize> = __zero_std_toml_string_value_end(value)
        return end.has && end.value == std.mem.len(value)
    }
    if value[0] == 91_u8 {
        return __zero_std_toml_array_valid(value)
    }
    if std.mem.eql(value, "true") || std.mem.eql(value, "false") {
        return true
    }
    let signed: Maybe<i32> = std.parse.parseI32(value)
    if signed.has {
        return true
    }
    let unsigned: Maybe<u32> = std.parse.parseU32(value)
    return unsigned.has
}

fn __zero_std_toml_write_span(buffer: MutSpan<u8>, cursor: usize, bytes: Span<u8>) -> Maybe<usize> {
    if cursor + std.mem.len(bytes) > std.mem.len(buffer) {
        return null
    }
    var index: usize = 0
    while index < std.mem.len(bytes) {
        buffer[cursor + index] = bytes[index]
        index = index + 1
    }
    return cursor + std.mem.len(bytes)
}

fn __zero_std_toml_write_escaped_string(buffer: MutSpan<u8>, cursor: usize, value: Span<u8>) -> Maybe<usize> {
    var output: usize = cursor
    let open_end: Maybe<usize> = __zero_std_toml_write_span(buffer, output, "\"")
    if !open_end.has {
        return null
    }
    output = open_end.value
    var index: usize = 0
    while index < std.mem.len(value) {
        let byte: u8 = value[index]
        if byte == 34_u8 {
            let next: Maybe<usize> = __zero_std_toml_write_span(buffer, output, "\\\"")
            if !next.has {
                return null
            }
            output = next.value
        } else if byte == 92_u8 {
            let next: Maybe<usize> = __zero_std_toml_write_span(buffer, output, "\\\\")
            if !next.has {
                return null
            }
            output = next.value
        } else if byte == 10_u8 {
            let next: Maybe<usize> = __zero_std_toml_write_span(buffer, output, "\\n")
            if !next.has {
                return null
            }
            output = next.value
        } else if byte == 13_u8 {
            let next: Maybe<usize> = __zero_std_toml_write_span(buffer, output, "\\r")
            if !next.has {
                return null
            }
            output = next.value
        } else if byte == 9_u8 {
            let next: Maybe<usize> = __zero_std_toml_write_span(buffer, output, "\\t")
            if !next.has {
                return null
            }
            output = next.value
        } else {
            if byte < 32_u8 || output >= std.mem.len(buffer) {
                return null
            }
            buffer[output] = byte
            output = output + 1
        }
        index = index + 1
    }
    return __zero_std_toml_write_span(buffer, output, "\"")
}

fn __zero_std_toml_span_eq(left: Span<u8>, right: Span<u8>) -> Bool {
    if std.mem.len(left) != std.mem.len(right) {
        return false
    }
    var index: usize = 0
    while index < std.mem.len(right) {
        if left[index] != right[index] {
            return false
        }
        index = index + 1
    }
    return true
}

fn __zero_std_toml_key_matches(table: Span<u8>, field: Span<u8>, query: Span<u8>) -> Bool {
    if __zero_std_toml_span_eq(field, query) {
        return true
    }
    if std.mem.len(table) == 0 {
        return false
    }
    let table_len: usize = std.mem.len(table)
    let field_len: usize = std.mem.len(field)
    if std.mem.len(query) != table_len + 1 + field_len {
        return false
    }
    var index: usize = 0
    while index < table_len {
        if query[index] != table[index] {
            return false
        }
        index = index + 1
    }
    if query[table_len] != 46_u8 {
        return false
    }
    var field_index: usize = 0
    while field_index < field_len {
        if query[table_len + 1 + field_index] != field[field_index] {
            return false
        }
        field_index = field_index + 1
    }
    return true
}