fn __zero_std_cli_arg_equals(index: usize, expected: String) -> Bool {
    let value: Maybe<String> = std.args.get(index)
    return value.has && std.mem.eql(value.value, expected)
}

fn __zero_std_cli_has_flag(name: String) -> Bool {
    let index: Maybe<usize> = std.args.find(name)
    return index.has
}

fn __zero_std_cli_option_value(name: String) -> Maybe<String> {
    let value: Maybe<String> = std.args.valueAfter(name)
    return value
}

fn __zero_std_cli_option_value_or(name: String, fallback: String) -> String {
    let value: Maybe<String> = std.args.valueAfter(name)
    if value.has {
        return value.value
    }
    return fallback
}

fn __zero_std_cli_option_u32(name: String) -> Maybe<u32> {
    let value: Maybe<String> = std.args.valueAfter(name)
    if value.has {
        return std.parse.parseU32(value.value)
    }
    return null
}

fn __zero_std_cli_option_bool(name: String) -> Maybe<Bool> {
    let value: Maybe<String> = std.args.valueAfter(name)
    if value.has {
        return std.parse.parseBool(value.value)
    }
    return null
}

fn __zero_std_cli_option_bool_or(name: String, fallback: Bool) -> Bool {
    let value: Maybe<Bool> = __zero_std_cli_option_bool(name)
    if value.has {
        return value.value
    }
    return fallback
}

fn __zero_std_cli_option_i32(name: String) -> Maybe<i32> {
    let value: Maybe<String> = std.args.valueAfter(name)
    if value.has {
        return std.parse.parseI32(value.value)
    }
    return null
}

fn __zero_std_cli_option_i32_or(name: String, fallback: i32) -> i32 {
    let value: Maybe<i32> = __zero_std_cli_option_i32(name)
    if value.has {
        return value.value
    }
    return fallback
}

fn __zero_std_cli_option_u32_or(name: String, fallback: u32) -> u32 {
    let value: Maybe<u32> = __zero_std_cli_option_u32(name)
    if value.has {
        return value.value
    }
    return fallback
}

fn __zero_std_cli_option_usize(name: String) -> Maybe<usize> {
    let value: Maybe<String> = std.args.valueAfter(name)
    if value.has {
        return std.parse.parseUsize(value.value)
    }
    return null
}

fn __zero_std_cli_option_usize_or(name: String, fallback: usize) -> usize {
    let value: Maybe<usize> = __zero_std_cli_option_usize(name)
    if value.has {
        return value.value
    }
    return fallback
}

fn __zero_std_cli_success_exit_code() -> i32 {
    return 0
}

fn __zero_std_cli_usage_exit_code() -> i32 {
    return 2
}

fn __zero_std_cli_command() -> Maybe<String> {
    let command: Maybe<String> = std.args.get(1)
    return command
}

fn __zero_std_cli_command_or(fallback: String) -> String {
    return std.args.getOr(1, fallback)
}

fn __zero_std_cli_command_equals(expected: String) -> Bool {
    return __zero_std_cli_arg_equals(1, expected)
}

fn __zero_std_cli_arg_or(index: usize, fallback: String) -> String {
    return std.args.getOr(index, fallback)
}

fn __zero_std_cli_arg_u32_or(index: usize, fallback: u32) -> u32 {
    let value: Maybe<u32> = std.args.parseU32(index)
    if value.has {
        return value.value
    }
    return fallback
}

fn __zero_std_cli_is_help(command: Span<u8>) -> Bool {
    return std.mem.eql(command, "help") || std.mem.eql(command, "--help") || std.mem.eql(command, "-h")
}

fn __zero_std_cli_needs_help() -> Bool {
    if !std.args.has(1) {
        return true
    }
    return std.cli.argEquals(1, "help") || std.cli.argEquals(1, "--help") || std.cli.argEquals(1, "-h")
}

fn __zero_std_cli_command_in2(command: Span<u8>, first: Span<u8>, second: Span<u8>) -> Bool {
    return std.mem.eql(command, first) || std.mem.eql(command, second)
}

fn __zero_std_cli_command_in3(command: Span<u8>, first: Span<u8>, second: Span<u8>, third: Span<u8>) -> Bool {
    return std.mem.eql(command, first) || std.mem.eql(command, second) || std.mem.eql(command, third)
}

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

fn __zero_std_cli_format_usage(buffer: MutSpan<u8>, program: Span<u8>, syntax: Span<u8>) -> Maybe<Span<u8>> {
    var offset: usize = 0
    let prefix: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "usage: ")
    if !prefix.has {
        return null
    }
    offset = prefix.value
    let wrote_program: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, program)
    if !wrote_program.has {
        return null
    }
    offset = wrote_program.value
    let space: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, " ")
    if !space.has {
        return null
    }
    offset = space.value
    let wrote_syntax: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, syntax)
    if wrote_syntax.has {
        return buffer[..wrote_syntax.value]
    }
    return null
}

fn __zero_std_cli_format_command(buffer: MutSpan<u8>, name: Span<u8>, syntax: Span<u8>, summary: Span<u8>) -> Maybe<Span<u8>> {
    var offset: usize = 0
    let indent: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "  ")
    if !indent.has {
        return null
    }
    offset = indent.value
    let wrote_name: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, name)
    if !wrote_name.has {
        return null
    }
    offset = wrote_name.value
    if std.mem.len(syntax) > 0 {
        let name_space: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, " ")
        if !name_space.has {
            return null
        }
        offset = name_space.value
        let wrote_syntax: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, syntax)
        if !wrote_syntax.has {
            return null
        }
        offset = wrote_syntax.value
    }
    let gap: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "  ")
    if !gap.has {
        return null
    }
    offset = gap.value
    let wrote_summary: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, summary)
    if wrote_summary.has {
        return buffer[..wrote_summary.value]
    }
    return null
}

fn __zero_std_cli_format_option(buffer: MutSpan<u8>, name: Span<u8>, value_name: Span<u8>, summary: Span<u8>) -> Maybe<Span<u8>> {
    return __zero_std_cli_format_command(buffer, name, value_name, summary)
}

fn __zero_std_cli_format_error(buffer: MutSpan<u8>, message: Span<u8>) -> Maybe<Span<u8>> {
    var offset: usize = 0
    let prefix: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "error: ")
    if !prefix.has {
        return null
    }
    offset = prefix.value
    let wrote_message: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, message)
    if wrote_message.has {
        return buffer[..wrote_message.value]
    }
    return null
}

fn __zero_std_cli_format_unknown_command(buffer: MutSpan<u8>, command: Span<u8>) -> Maybe<Span<u8>> {
    var offset: usize = 0
    let prefix: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "error: unknown command: ")
    if !prefix.has {
        return null
    }
    offset = prefix.value
    let wrote_command: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, command)
    if wrote_command.has {
        return buffer[..wrote_command.value]
    }
    return null
}

fn __zero_std_cli_format_missing_operand(buffer: MutSpan<u8>, operand: Span<u8>) -> Maybe<Span<u8>> {
    var offset: usize = 0
    let prefix: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "error: missing operand: ")
    if !prefix.has {
        return null
    }
    offset = prefix.value
    let wrote_operand: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, operand)
    if wrote_operand.has {
        return buffer[..wrote_operand.value]
    }
    return null
}

fn __zero_std_cli_format_invalid_option(buffer: MutSpan<u8>, option: Span<u8>) -> Maybe<Span<u8>> {
    var offset: usize = 0
    let prefix: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "error: invalid option: ")
    if !prefix.has {
        return null
    }
    offset = prefix.value
    let wrote_option: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, option)
    if wrote_option.has {
        return buffer[..wrote_option.value]
    }
    return null
}

fn __zero_std_cli_format_section(buffer: MutSpan<u8>, title: Span<u8>) -> Maybe<Span<u8>> {
    var offset: usize = 0
    let wrote_title: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, title)
    if !wrote_title.has {
        return null
    }
    offset = wrote_title.value
    let colon: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, ":\n")
    if colon.has {
        return buffer[..colon.value]
    }
    return null
}

fn __zero_std_cli_format_help_row_with_width(buffer: MutSpan<u8>, label: Span<u8>, summary: Span<u8>, width: usize) -> Maybe<Span<u8>> {
    return __zero_std_cli_format_help_row_custom(buffer, label, summary, 2_usize, width)
}

fn __zero_std_cli_format_help(buffer: MutSpan<u8>, usage: Span<u8>, description: Span<u8>) -> Maybe<Span<u8>> {
    var offset: usize = 0
    let usage_label: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "Usage: ")
    if !usage_label.has {
        return null
    }
    offset = usage_label.value
    let wrote_usage: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, usage)
    if !wrote_usage.has {
        return null
    }
    offset = wrote_usage.value
    let usage_newline: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "\n")
    if !usage_newline.has {
        return null
    }
    offset = usage_newline.value
    if std.mem.len(description) > 0_usize {
        let description_gap: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "\n")
        if !description_gap.has {
            return null
        }
        offset = description_gap.value
        let wrote_description: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, description)
        if !wrote_description.has {
            return null
        }
        offset = wrote_description.value
        let description_newline: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "\n")
        if !description_newline.has {
            return null
        }
        offset = description_newline.value
    }
    return buffer[..offset]
}

fn __zero_std_cli_format_help_row(buffer: MutSpan<u8>, label: Span<u8>, summary: Span<u8>) -> Maybe<Span<u8>> {
    return __zero_std_cli_format_help_row_custom(buffer, label, summary, 2_usize, 17_usize)
}

fn __zero_std_cli_format_help_row_custom(buffer: MutSpan<u8>, label: Span<u8>, summary: Span<u8>, indent: usize, width: usize) -> Maybe<Span<u8>> {
    var offset: usize = 0
    var indent_index: usize = 0
    while indent_index < indent {
        let indent_space: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, " ")
        if !indent_space.has {
            return null
        }
        offset = indent_space.value
        indent_index = indent_index + 1_usize
    }
    let wrote_label: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, label)
    if !wrote_label.has {
        return null
    }
    offset = wrote_label.value
    var spaces: usize = 2_usize
    if std.mem.len(label) < width {
        spaces = spaces + (width - std.mem.len(label))
    }
    var index: usize = 0
    while index < spaces {
        let space: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, " ")
        if !space.has {
            return null
        }
        offset = space.value
        index = index + 1_usize
    }
    let wrote_summary: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, summary)
    if !wrote_summary.has {
        return null
    }
    offset = wrote_summary.value
    let newline: Maybe<usize> = __zero_std_cli_write_span(buffer, offset, "\n")
    if newline.has {
        return buffer[..newline.value]
    }
    return null
}