_uu-coreutils() {
    local i cur prev opts cmds
    COMPREPLY=()
    cur="${COMP_WORDS[COMP_CWORD]}"
    prev="${COMP_WORDS[COMP_CWORD-1]}"
    cmd=""
    opts=""

    for i in ${COMP_WORDS[@]}
    do
        case "${i}" in
            "$1")
                cmd="uu__coreutils"
                ;;
            cat)
                cmd+="__cat"
                ;;
            cksum)
                cmd+="__cksum"
                ;;
            completion)
                cmd+="__completion"
                ;;
            cut)
                cmd+="__cut"
                ;;
            echo)
                cmd+="__echo"
                ;;
            fold)
                cmd+="__fold"
                ;;
            help)
                cmd+="__help"
                ;;
            join)
                cmd+="__join"
                ;;
            mkfifo)
                cmd+="__mkfifo"
                ;;
            nl)
                cmd+="__nl"
                ;;
            ptx)
                cmd+="__ptx"
                ;;
            shuf)
                cmd+="__shuf"
                ;;
            sum)
                cmd+="__sum"
                ;;
            tac)
                cmd+="__tac"
                ;;
            timeout)
                cmd+="__timeout"
                ;;
            unexpand)
                cmd+="__unexpand"
                ;;
            uu_env)
                cmd+="__uu_env"
                ;;
            uu_yes)
                cmd+="__uu_yes"
                ;;
            *)
                ;;
        esac
    done

    case "${cmd}" in
        uu__coreutils)
            opts="-h --help completion completion completion completion completion completion completion completion ptx completion completion completion uu_env completion completion join completion completion completion completion mkfifo completion completion completion fold completion completion completion completion shuf completion completion completion completion completion completion completion completion completion completion completion completion completion completion cksum completion nl completion completion timeout completion completion completion completion completion unexpand completion completion completion completion completion completion completion completion completion completion completion completion completion completion completion completion cut uu_yes completion completion completion completion completion completion completion completion completion completion completion completion completion completion completion completion completion completion sum completion completion completion tac completion completion completion completion completion completion completion completion completion completion completion echo completion cat completion completion completion completion completion help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__cat)
            opts="-V -A -b -e -E -n -s -t -T -v -h --version --show-all --number-nonblank --show-ends --number --squeeze-blank --t --show-tabs --show-nonprinting --help <file>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__cksum)
            opts="-V -h --version --help <file>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__completion)
            opts="-V -D -w -c -i -d -s -f -u -z -h --version --all-repeated --group --check-chars --count --ignore-case --repeated --skip-chars --skip-fields --unique --zero-terminated --help <files>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --all-repeated)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                -D)
                    COMPREPLY=($(compgen -W "none prepend separate" -- "${cur}"))
                    return 0
                    ;;
                --group)
                    COMPREPLY=($(compgen -W "separate prepend append both" -- "${cur}"))
                    return 0
                    ;;
                --check-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-chars)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --skip-fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__cut)
            opts="-V -b -c -d -f -s -z -h --version --bytes --characters --delimiter --fields --complement --only-delimited --zero-terminated --output-delimiter --help <file>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --bytes)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -b)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --characters)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --delimiter)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -d)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --fields)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output-delimiter)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__echo)
            opts="-V -n -e -E -h --version --help <STRING>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__fold)
            opts="-V -b -s -w -h --version --bytes --spaces --width --help <file>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --width)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__help)
            opts="<SUBCOMMAND>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__join)
            opts="-V -a -v -e -i -j -o -t -1 -2 -z -h --version --ignore-case --check-order --nocheck-order --header --zero-terminated --help <FILE1> <FILE2>"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                -a)
                    COMPREPLY=($(compgen -W "1 2" -- "${cur}"))
                    return 0
                    ;;
                -v)
                    COMPREPLY=($(compgen -W "1 2" -- "${cur}"))
                    return 0
                    ;;
                -e)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -j)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -1)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -2)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__mkfifo)
            opts="-V -m -Z -h --version --mode --context --help <fifo>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --mode)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -m)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --context)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__nl)
            opts="-V -b -d -f -h -i -l -n -p -s -v -w --version --help --body-numbering --section-delimiter --footer-numbering --header-numbering --line-increment --join-blank-lines --number-format --no-renumber --number-separator --starting-line-number --number-width <file>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --body-numbering)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -b)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --section-delimiter)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -d)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --footer-numbering)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --header-numbering)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -h)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --line-increment)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -i)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --join-blank-lines)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -l)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --number-format)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -n)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --number-separator)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --starting-line-number)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -v)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --number-width)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__ptx)
            opts="-V -A -G -F -M -O -R -S -T -W -b -f -g -i -o -r -w -h --version --auto-reference --traditional --flag-truncation --macro-name --format=roff --right-side-refs --sentence-regexp --format=tex --word-regexp --break-file --ignore-case --gap-size --ignore-file --only-file --references --width --help <file>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --flag-truncation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -F)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --macro-name)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -M)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --sentence-regexp)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -S)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --word-regexp)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -W)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --break-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -b)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gap-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -g)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --ignore-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -i)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --only-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --width)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__shuf)
            opts="-V -e -i -n -o -r -z -h --version --echo --input-range --head-count --output --random-source --repeat --zero-terminated --help <file>"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --echo)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -e)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --input-range)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -i)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --head-count)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -n)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --random-source)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__sum)
            opts="-V -r -s -h --version --sysv --help <file>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__tac)
            opts="-V -b -r -s -h --version --before --regex --separator --help <file>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --separator)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__timeout)
            opts="-V -k -s -v -h --version --foreground --kill-after --preserve-status --signal --verbose --help <duration> <command>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --kill-after)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -k)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signal)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__unexpand)
            opts="-V -a -t -U -h --version --all --first-only --tabs --no-utf8 --help <file>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --tabs)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__uu_env)
            opts="-V -i -C -0 -f -u -h --version --ignore-environment --chdir --null --file --unset --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --chdir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -C)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --unset)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -u)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        uu__coreutils__uu_yes)
            opts="-V -h --version --help <STRING>..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
    esac
}

complete -F _uu-coreutils -o bashdefault -o default uu-coreutils
