_sq() {
    local i cur prev opts cmd
    COMPREPLY=()
    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
        cur="$2"
    else
        cur="${COMP_WORDS[COMP_CWORD]}"
    fi
    prev="$3"
    cmd=""
    opts=""

    for i in "${COMP_WORDS[@]:0:COMP_CWORD}"
    do
        case "${cmd},${i}" in
            ",$1")
                cmd="sq"
                ;;
            sq,cert)
                cmd="sq__subcmd__cert"
                ;;
            sq,config)
                cmd="sq__subcmd__config"
                ;;
            sq,decrypt)
                cmd="sq__subcmd__decrypt"
                ;;
            sq,download)
                cmd="sq__subcmd__download"
                ;;
            sq,encrypt)
                cmd="sq__subcmd__encrypt"
                ;;
            sq,help)
                cmd="sq__subcmd__help"
                ;;
            sq,inspect)
                cmd="sq__subcmd__inspect"
                ;;
            sq,key)
                cmd="sq__subcmd__key"
                ;;
            sq,keyring)
                cmd="sq__subcmd__keyring"
                ;;
            sq,network)
                cmd="sq__subcmd__network"
                ;;
            sq,packet)
                cmd="sq__subcmd__packet"
                ;;
            sq,pki)
                cmd="sq__subcmd__pki"
                ;;
            sq,sign)
                cmd="sq__subcmd__sign"
                ;;
            sq,verify)
                cmd="sq__subcmd__verify"
                ;;
            sq,version)
                cmd="sq__subcmd__version"
                ;;
            sq__subcmd__cert,export)
                cmd="sq__subcmd__cert__subcmd__export"
                ;;
            sq__subcmd__cert,import)
                cmd="sq__subcmd__cert__subcmd__import"
                ;;
            sq__subcmd__cert,lint)
                cmd="sq__subcmd__cert__subcmd__lint"
                ;;
            sq__subcmd__cert,list)
                cmd="sq__subcmd__cert__subcmd__list"
                ;;
            sq__subcmd__config,get)
                cmd="sq__subcmd__config__subcmd__get"
                ;;
            sq__subcmd__config,inspect)
                cmd="sq__subcmd__config__subcmd__inspect"
                ;;
            sq__subcmd__config,template)
                cmd="sq__subcmd__config__subcmd__template"
                ;;
            sq__subcmd__config__subcmd__inspect,network)
                cmd="sq__subcmd__config__subcmd__inspect__subcmd__network"
                ;;
            sq__subcmd__config__subcmd__inspect,paths)
                cmd="sq__subcmd__config__subcmd__inspect__subcmd__paths"
                ;;
            sq__subcmd__config__subcmd__inspect,policy)
                cmd="sq__subcmd__config__subcmd__inspect__subcmd__policy"
                ;;
            sq__subcmd__help,cert)
                cmd="sq__subcmd__help__subcmd__cert"
                ;;
            sq__subcmd__help,config)
                cmd="sq__subcmd__help__subcmd__config"
                ;;
            sq__subcmd__help,decrypt)
                cmd="sq__subcmd__help__subcmd__decrypt"
                ;;
            sq__subcmd__help,download)
                cmd="sq__subcmd__help__subcmd__download"
                ;;
            sq__subcmd__help,encrypt)
                cmd="sq__subcmd__help__subcmd__encrypt"
                ;;
            sq__subcmd__help,help)
                cmd="sq__subcmd__help__subcmd__help"
                ;;
            sq__subcmd__help,inspect)
                cmd="sq__subcmd__help__subcmd__inspect"
                ;;
            sq__subcmd__help,key)
                cmd="sq__subcmd__help__subcmd__key"
                ;;
            sq__subcmd__help,keyring)
                cmd="sq__subcmd__help__subcmd__keyring"
                ;;
            sq__subcmd__help,network)
                cmd="sq__subcmd__help__subcmd__network"
                ;;
            sq__subcmd__help,packet)
                cmd="sq__subcmd__help__subcmd__packet"
                ;;
            sq__subcmd__help,pki)
                cmd="sq__subcmd__help__subcmd__pki"
                ;;
            sq__subcmd__help,sign)
                cmd="sq__subcmd__help__subcmd__sign"
                ;;
            sq__subcmd__help,verify)
                cmd="sq__subcmd__help__subcmd__verify"
                ;;
            sq__subcmd__help,version)
                cmd="sq__subcmd__help__subcmd__version"
                ;;
            sq__subcmd__help__subcmd__cert,export)
                cmd="sq__subcmd__help__subcmd__cert__subcmd__export"
                ;;
            sq__subcmd__help__subcmd__cert,import)
                cmd="sq__subcmd__help__subcmd__cert__subcmd__import"
                ;;
            sq__subcmd__help__subcmd__cert,lint)
                cmd="sq__subcmd__help__subcmd__cert__subcmd__lint"
                ;;
            sq__subcmd__help__subcmd__cert,list)
                cmd="sq__subcmd__help__subcmd__cert__subcmd__list"
                ;;
            sq__subcmd__help__subcmd__config,get)
                cmd="sq__subcmd__help__subcmd__config__subcmd__get"
                ;;
            sq__subcmd__help__subcmd__config,inspect)
                cmd="sq__subcmd__help__subcmd__config__subcmd__inspect"
                ;;
            sq__subcmd__help__subcmd__config,template)
                cmd="sq__subcmd__help__subcmd__config__subcmd__template"
                ;;
            sq__subcmd__help__subcmd__config__subcmd__inspect,network)
                cmd="sq__subcmd__help__subcmd__config__subcmd__inspect__subcmd__network"
                ;;
            sq__subcmd__help__subcmd__config__subcmd__inspect,paths)
                cmd="sq__subcmd__help__subcmd__config__subcmd__inspect__subcmd__paths"
                ;;
            sq__subcmd__help__subcmd__config__subcmd__inspect,policy)
                cmd="sq__subcmd__help__subcmd__config__subcmd__inspect__subcmd__policy"
                ;;
            sq__subcmd__help__subcmd__key,approvals)
                cmd="sq__subcmd__help__subcmd__key__subcmd__approvals"
                ;;
            sq__subcmd__help__subcmd__key,delete)
                cmd="sq__subcmd__help__subcmd__key__subcmd__delete"
                ;;
            sq__subcmd__help__subcmd__key,expire)
                cmd="sq__subcmd__help__subcmd__key__subcmd__expire"
                ;;
            sq__subcmd__help__subcmd__key,export)
                cmd="sq__subcmd__help__subcmd__key__subcmd__export"
                ;;
            sq__subcmd__help__subcmd__key,generate)
                cmd="sq__subcmd__help__subcmd__key__subcmd__generate"
                ;;
            sq__subcmd__help__subcmd__key,import)
                cmd="sq__subcmd__help__subcmd__key__subcmd__import"
                ;;
            sq__subcmd__help__subcmd__key,list)
                cmd="sq__subcmd__help__subcmd__key__subcmd__list"
                ;;
            sq__subcmd__help__subcmd__key,password)
                cmd="sq__subcmd__help__subcmd__key__subcmd__password"
                ;;
            sq__subcmd__help__subcmd__key,revoke)
                cmd="sq__subcmd__help__subcmd__key__subcmd__revoke"
                ;;
            sq__subcmd__help__subcmd__key,rotate)
                cmd="sq__subcmd__help__subcmd__key__subcmd__rotate"
                ;;
            sq__subcmd__help__subcmd__key,subkey)
                cmd="sq__subcmd__help__subcmd__key__subcmd__subkey"
                ;;
            sq__subcmd__help__subcmd__key,userid)
                cmd="sq__subcmd__help__subcmd__key__subcmd__userid"
                ;;
            sq__subcmd__help__subcmd__key__subcmd__approvals,list)
                cmd="sq__subcmd__help__subcmd__key__subcmd__approvals__subcmd__list"
                ;;
            sq__subcmd__help__subcmd__key__subcmd__approvals,update)
                cmd="sq__subcmd__help__subcmd__key__subcmd__approvals__subcmd__update"
                ;;
            sq__subcmd__help__subcmd__key__subcmd__subkey,add)
                cmd="sq__subcmd__help__subcmd__key__subcmd__subkey__subcmd__add"
                ;;
            sq__subcmd__help__subcmd__key__subcmd__subkey,bind)
                cmd="sq__subcmd__help__subcmd__key__subcmd__subkey__subcmd__bind"
                ;;
            sq__subcmd__help__subcmd__key__subcmd__subkey,delete)
                cmd="sq__subcmd__help__subcmd__key__subcmd__subkey__subcmd__delete"
                ;;
            sq__subcmd__help__subcmd__key__subcmd__subkey,expire)
                cmd="sq__subcmd__help__subcmd__key__subcmd__subkey__subcmd__expire"
                ;;
            sq__subcmd__help__subcmd__key__subcmd__subkey,export)
                cmd="sq__subcmd__help__subcmd__key__subcmd__subkey__subcmd__export"
                ;;
            sq__subcmd__help__subcmd__key__subcmd__subkey,password)
                cmd="sq__subcmd__help__subcmd__key__subcmd__subkey__subcmd__password"
                ;;
            sq__subcmd__help__subcmd__key__subcmd__subkey,revoke)
                cmd="sq__subcmd__help__subcmd__key__subcmd__subkey__subcmd__revoke"
                ;;
            sq__subcmd__help__subcmd__key__subcmd__userid,add)
                cmd="sq__subcmd__help__subcmd__key__subcmd__userid__subcmd__add"
                ;;
            sq__subcmd__help__subcmd__key__subcmd__userid,revoke)
                cmd="sq__subcmd__help__subcmd__key__subcmd__userid__subcmd__revoke"
                ;;
            sq__subcmd__help__subcmd__keyring,filter)
                cmd="sq__subcmd__help__subcmd__keyring__subcmd__filter"
                ;;
            sq__subcmd__help__subcmd__keyring,list)
                cmd="sq__subcmd__help__subcmd__keyring__subcmd__list"
                ;;
            sq__subcmd__help__subcmd__keyring,merge)
                cmd="sq__subcmd__help__subcmd__keyring__subcmd__merge"
                ;;
            sq__subcmd__help__subcmd__keyring,split)
                cmd="sq__subcmd__help__subcmd__keyring__subcmd__split"
                ;;
            sq__subcmd__help__subcmd__network,dane)
                cmd="sq__subcmd__help__subcmd__network__subcmd__dane"
                ;;
            sq__subcmd__help__subcmd__network,keyserver)
                cmd="sq__subcmd__help__subcmd__network__subcmd__keyserver"
                ;;
            sq__subcmd__help__subcmd__network,search)
                cmd="sq__subcmd__help__subcmd__network__subcmd__search"
                ;;
            sq__subcmd__help__subcmd__network,wkd)
                cmd="sq__subcmd__help__subcmd__network__subcmd__wkd"
                ;;
            sq__subcmd__help__subcmd__network__subcmd__dane,generate)
                cmd="sq__subcmd__help__subcmd__network__subcmd__dane__subcmd__generate"
                ;;
            sq__subcmd__help__subcmd__network__subcmd__dane,search)
                cmd="sq__subcmd__help__subcmd__network__subcmd__dane__subcmd__search"
                ;;
            sq__subcmd__help__subcmd__network__subcmd__keyserver,publish)
                cmd="sq__subcmd__help__subcmd__network__subcmd__keyserver__subcmd__publish"
                ;;
            sq__subcmd__help__subcmd__network__subcmd__keyserver,search)
                cmd="sq__subcmd__help__subcmd__network__subcmd__keyserver__subcmd__search"
                ;;
            sq__subcmd__help__subcmd__network__subcmd__wkd,publish)
                cmd="sq__subcmd__help__subcmd__network__subcmd__wkd__subcmd__publish"
                ;;
            sq__subcmd__help__subcmd__network__subcmd__wkd,search)
                cmd="sq__subcmd__help__subcmd__network__subcmd__wkd__subcmd__search"
                ;;
            sq__subcmd__help__subcmd__packet,armor)
                cmd="sq__subcmd__help__subcmd__packet__subcmd__armor"
                ;;
            sq__subcmd__help__subcmd__packet,dearmor)
                cmd="sq__subcmd__help__subcmd__packet__subcmd__dearmor"
                ;;
            sq__subcmd__help__subcmd__packet,decrypt)
                cmd="sq__subcmd__help__subcmd__packet__subcmd__decrypt"
                ;;
            sq__subcmd__help__subcmd__packet,dump)
                cmd="sq__subcmd__help__subcmd__packet__subcmd__dump"
                ;;
            sq__subcmd__help__subcmd__packet,join)
                cmd="sq__subcmd__help__subcmd__packet__subcmd__join"
                ;;
            sq__subcmd__help__subcmd__packet,split)
                cmd="sq__subcmd__help__subcmd__packet__subcmd__split"
                ;;
            sq__subcmd__help__subcmd__pki,authenticate)
                cmd="sq__subcmd__help__subcmd__pki__subcmd__authenticate"
                ;;
            sq__subcmd__help__subcmd__pki,identify)
                cmd="sq__subcmd__help__subcmd__pki__subcmd__identify"
                ;;
            sq__subcmd__help__subcmd__pki,link)
                cmd="sq__subcmd__help__subcmd__pki__subcmd__link"
                ;;
            sq__subcmd__help__subcmd__pki,lookup)
                cmd="sq__subcmd__help__subcmd__pki__subcmd__lookup"
                ;;
            sq__subcmd__help__subcmd__pki,path)
                cmd="sq__subcmd__help__subcmd__pki__subcmd__path"
                ;;
            sq__subcmd__help__subcmd__pki,vouch)
                cmd="sq__subcmd__help__subcmd__pki__subcmd__vouch"
                ;;
            sq__subcmd__help__subcmd__pki__subcmd__link,add)
                cmd="sq__subcmd__help__subcmd__pki__subcmd__link__subcmd__add"
                ;;
            sq__subcmd__help__subcmd__pki__subcmd__link,authorize)
                cmd="sq__subcmd__help__subcmd__pki__subcmd__link__subcmd__authorize"
                ;;
            sq__subcmd__help__subcmd__pki__subcmd__link,list)
                cmd="sq__subcmd__help__subcmd__pki__subcmd__link__subcmd__list"
                ;;
            sq__subcmd__help__subcmd__pki__subcmd__link,retract)
                cmd="sq__subcmd__help__subcmd__pki__subcmd__link__subcmd__retract"
                ;;
            sq__subcmd__help__subcmd__pki__subcmd__vouch,add)
                cmd="sq__subcmd__help__subcmd__pki__subcmd__vouch__subcmd__add"
                ;;
            sq__subcmd__help__subcmd__pki__subcmd__vouch,authorize)
                cmd="sq__subcmd__help__subcmd__pki__subcmd__vouch__subcmd__authorize"
                ;;
            sq__subcmd__help__subcmd__pki__subcmd__vouch,list)
                cmd="sq__subcmd__help__subcmd__pki__subcmd__vouch__subcmd__list"
                ;;
            sq__subcmd__help__subcmd__pki__subcmd__vouch,replay)
                cmd="sq__subcmd__help__subcmd__pki__subcmd__vouch__subcmd__replay"
                ;;
            sq__subcmd__key,approvals)
                cmd="sq__subcmd__key__subcmd__approvals"
                ;;
            sq__subcmd__key,delete)
                cmd="sq__subcmd__key__subcmd__delete"
                ;;
            sq__subcmd__key,expire)
                cmd="sq__subcmd__key__subcmd__expire"
                ;;
            sq__subcmd__key,export)
                cmd="sq__subcmd__key__subcmd__export"
                ;;
            sq__subcmd__key,generate)
                cmd="sq__subcmd__key__subcmd__generate"
                ;;
            sq__subcmd__key,import)
                cmd="sq__subcmd__key__subcmd__import"
                ;;
            sq__subcmd__key,list)
                cmd="sq__subcmd__key__subcmd__list"
                ;;
            sq__subcmd__key,password)
                cmd="sq__subcmd__key__subcmd__password"
                ;;
            sq__subcmd__key,revoke)
                cmd="sq__subcmd__key__subcmd__revoke"
                ;;
            sq__subcmd__key,rotate)
                cmd="sq__subcmd__key__subcmd__rotate"
                ;;
            sq__subcmd__key,subkey)
                cmd="sq__subcmd__key__subcmd__subkey"
                ;;
            sq__subcmd__key,userid)
                cmd="sq__subcmd__key__subcmd__userid"
                ;;
            sq__subcmd__key__subcmd__approvals,list)
                cmd="sq__subcmd__key__subcmd__approvals__subcmd__list"
                ;;
            sq__subcmd__key__subcmd__approvals,update)
                cmd="sq__subcmd__key__subcmd__approvals__subcmd__update"
                ;;
            sq__subcmd__key__subcmd__subkey,add)
                cmd="sq__subcmd__key__subcmd__subkey__subcmd__add"
                ;;
            sq__subcmd__key__subcmd__subkey,bind)
                cmd="sq__subcmd__key__subcmd__subkey__subcmd__bind"
                ;;
            sq__subcmd__key__subcmd__subkey,delete)
                cmd="sq__subcmd__key__subcmd__subkey__subcmd__delete"
                ;;
            sq__subcmd__key__subcmd__subkey,expire)
                cmd="sq__subcmd__key__subcmd__subkey__subcmd__expire"
                ;;
            sq__subcmd__key__subcmd__subkey,export)
                cmd="sq__subcmd__key__subcmd__subkey__subcmd__export"
                ;;
            sq__subcmd__key__subcmd__subkey,password)
                cmd="sq__subcmd__key__subcmd__subkey__subcmd__password"
                ;;
            sq__subcmd__key__subcmd__subkey,revoke)
                cmd="sq__subcmd__key__subcmd__subkey__subcmd__revoke"
                ;;
            sq__subcmd__key__subcmd__userid,add)
                cmd="sq__subcmd__key__subcmd__userid__subcmd__add"
                ;;
            sq__subcmd__key__subcmd__userid,revoke)
                cmd="sq__subcmd__key__subcmd__userid__subcmd__revoke"
                ;;
            sq__subcmd__keyring,filter)
                cmd="sq__subcmd__keyring__subcmd__filter"
                ;;
            sq__subcmd__keyring,list)
                cmd="sq__subcmd__keyring__subcmd__list"
                ;;
            sq__subcmd__keyring,merge)
                cmd="sq__subcmd__keyring__subcmd__merge"
                ;;
            sq__subcmd__keyring,split)
                cmd="sq__subcmd__keyring__subcmd__split"
                ;;
            sq__subcmd__network,dane)
                cmd="sq__subcmd__network__subcmd__dane"
                ;;
            sq__subcmd__network,keyserver)
                cmd="sq__subcmd__network__subcmd__keyserver"
                ;;
            sq__subcmd__network,search)
                cmd="sq__subcmd__network__subcmd__search"
                ;;
            sq__subcmd__network,wkd)
                cmd="sq__subcmd__network__subcmd__wkd"
                ;;
            sq__subcmd__network__subcmd__dane,generate)
                cmd="sq__subcmd__network__subcmd__dane__subcmd__generate"
                ;;
            sq__subcmd__network__subcmd__dane,search)
                cmd="sq__subcmd__network__subcmd__dane__subcmd__search"
                ;;
            sq__subcmd__network__subcmd__keyserver,publish)
                cmd="sq__subcmd__network__subcmd__keyserver__subcmd__publish"
                ;;
            sq__subcmd__network__subcmd__keyserver,search)
                cmd="sq__subcmd__network__subcmd__keyserver__subcmd__search"
                ;;
            sq__subcmd__network__subcmd__wkd,publish)
                cmd="sq__subcmd__network__subcmd__wkd__subcmd__publish"
                ;;
            sq__subcmd__network__subcmd__wkd,search)
                cmd="sq__subcmd__network__subcmd__wkd__subcmd__search"
                ;;
            sq__subcmd__packet,armor)
                cmd="sq__subcmd__packet__subcmd__armor"
                ;;
            sq__subcmd__packet,dearmor)
                cmd="sq__subcmd__packet__subcmd__dearmor"
                ;;
            sq__subcmd__packet,decrypt)
                cmd="sq__subcmd__packet__subcmd__decrypt"
                ;;
            sq__subcmd__packet,dump)
                cmd="sq__subcmd__packet__subcmd__dump"
                ;;
            sq__subcmd__packet,join)
                cmd="sq__subcmd__packet__subcmd__join"
                ;;
            sq__subcmd__packet,split)
                cmd="sq__subcmd__packet__subcmd__split"
                ;;
            sq__subcmd__pki,authenticate)
                cmd="sq__subcmd__pki__subcmd__authenticate"
                ;;
            sq__subcmd__pki,identify)
                cmd="sq__subcmd__pki__subcmd__identify"
                ;;
            sq__subcmd__pki,link)
                cmd="sq__subcmd__pki__subcmd__link"
                ;;
            sq__subcmd__pki,lookup)
                cmd="sq__subcmd__pki__subcmd__lookup"
                ;;
            sq__subcmd__pki,path)
                cmd="sq__subcmd__pki__subcmd__path"
                ;;
            sq__subcmd__pki,vouch)
                cmd="sq__subcmd__pki__subcmd__vouch"
                ;;
            sq__subcmd__pki__subcmd__link,add)
                cmd="sq__subcmd__pki__subcmd__link__subcmd__add"
                ;;
            sq__subcmd__pki__subcmd__link,authorize)
                cmd="sq__subcmd__pki__subcmd__link__subcmd__authorize"
                ;;
            sq__subcmd__pki__subcmd__link,list)
                cmd="sq__subcmd__pki__subcmd__link__subcmd__list"
                ;;
            sq__subcmd__pki__subcmd__link,retract)
                cmd="sq__subcmd__pki__subcmd__link__subcmd__retract"
                ;;
            sq__subcmd__pki__subcmd__vouch,add)
                cmd="sq__subcmd__pki__subcmd__vouch__subcmd__add"
                ;;
            sq__subcmd__pki__subcmd__vouch,authorize)
                cmd="sq__subcmd__pki__subcmd__vouch__subcmd__authorize"
                ;;
            sq__subcmd__pki__subcmd__vouch,list)
                cmd="sq__subcmd__pki__subcmd__vouch__subcmd__list"
                ;;
            sq__subcmd__pki__subcmd__vouch,replay)
                cmd="sq__subcmd__pki__subcmd__vouch__subcmd__replay"
                ;;
            *)
                ;;
        esac
    done

    case "${cmd}" in
        sq)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help encrypt decrypt sign verify download inspect cert key pki network keyring packet config version help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__cert)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help import export list lint"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__cert__subcmd__export)
            opts="-v -q -h --output --local --all --cert --cert-userid --cert-email --cert-domain --cert-grep --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-domain)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-grep)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__cert__subcmd__import)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__cert__subcmd__lint)
            opts="-v -q -h --fix --cert --cert-userid --cert-email --cert-domain --cert-grep --cert-file --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-domain)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-grep)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__cert__subcmd__list)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-domain --cert-grep --show-paths --gossip --unusable --certification-network --amount --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-domain)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-grep)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --amount)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__config)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help get inspect template"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__config__subcmd__get)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__config__subcmd__inspect)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help paths network policy"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__config__subcmd__inspect__subcmd__network)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__config__subcmd__inspect__subcmd__paths)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__config__subcmd__inspect__subcmd__policy)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__config__subcmd__template)
            opts="-v -q -h --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__decrypt)
            opts="-v -q -h --output --signatures --signer --signer-userid --signer-email --signer-domain --signer-file --recipient-file --dump-session-key --session-key --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signatures)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer-domain)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --recipient-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --session-key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__download)
            opts="-v -q -h --url --signature-url --message --cleartext --signer --signer-userid --signer-email --signer-domain --signer-file --signatures --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --url)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signature-url)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer-domain)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signatures)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__encrypt)
            opts="-v -q -h --output --binary --for --for-userid --for-email --for-file --for-self --with-password --with-password-file --set-metadata-filename --signer --signer-userid --signer-email --signer-file --signer-self --without-signature --signature-notation --encrypt-for --compression --use-expired-subkey --profile --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --for)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --for-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --for-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --for-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --with-password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --set-metadata-filename)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signature-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --encrypt-for)
                    COMPREPLY=($(compgen -W "transport storage universal" -- "${cur}"))
                    return 0
                    ;;
                --compression)
                    COMPREPLY=($(compgen -W "none pad zip zlib bzip2" -- "${cur}"))
                    return 0
                    ;;
                --profile)
                    COMPREPLY=($(compgen -W "rfc9580 rfc4880" -- "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help)
            opts="encrypt decrypt sign verify download inspect cert key pki network keyring packet config version help"
            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
            ;;
        sq__subcmd__help__subcmd__cert)
            opts="import export list lint"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__cert__subcmd__export)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__cert__subcmd__import)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__cert__subcmd__lint)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__cert__subcmd__list)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__config)
            opts="get inspect template"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__config__subcmd__get)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__config__subcmd__inspect)
            opts="paths network policy"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__config__subcmd__inspect__subcmd__network)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__config__subcmd__inspect__subcmd__paths)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__config__subcmd__inspect__subcmd__policy)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__config__subcmd__template)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__decrypt)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__download)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__encrypt)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__help)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__inspect)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key)
            opts="list generate rotate import export delete password expire revoke userid subkey approvals"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__approvals)
            opts="list update"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__approvals__subcmd__list)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__approvals__subcmd__update)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__delete)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__expire)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__export)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__generate)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__import)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__list)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__password)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__revoke)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__rotate)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__subkey)
            opts="add export delete password expire revoke bind"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__subkey__subcmd__add)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__subkey__subcmd__bind)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__subkey__subcmd__delete)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__subkey__subcmd__expire)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__subkey__subcmd__export)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__subkey__subcmd__password)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__subkey__subcmd__revoke)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__userid)
            opts="add revoke"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__userid__subcmd__add)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__key__subcmd__userid__subcmd__revoke)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__keyring)
            opts="list split merge filter"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__keyring__subcmd__filter)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__keyring__subcmd__list)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__keyring__subcmd__merge)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__keyring__subcmd__split)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__network)
            opts="search keyserver wkd dane"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__network__subcmd__dane)
            opts="search generate"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__network__subcmd__dane__subcmd__generate)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__network__subcmd__dane__subcmd__search)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__network__subcmd__keyserver)
            opts="search publish"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__network__subcmd__keyserver__subcmd__publish)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__network__subcmd__keyserver__subcmd__search)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__network__subcmd__search)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__network__subcmd__wkd)
            opts="search publish"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__network__subcmd__wkd__subcmd__publish)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__network__subcmd__wkd__subcmd__search)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__packet)
            opts="armor dearmor dump decrypt split join"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__packet__subcmd__armor)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__packet__subcmd__dearmor)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__packet__subcmd__decrypt)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__packet__subcmd__dump)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__packet__subcmd__join)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__packet__subcmd__split)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__pki)
            opts="authenticate lookup identify vouch link path"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__pki__subcmd__authenticate)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__pki__subcmd__identify)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__pki__subcmd__link)
            opts="add authorize retract list"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__pki__subcmd__link__subcmd__add)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__pki__subcmd__link__subcmd__authorize)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__pki__subcmd__link__subcmd__list)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__pki__subcmd__link__subcmd__retract)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__pki__subcmd__lookup)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__pki__subcmd__path)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__pki__subcmd__vouch)
            opts="add authorize list replay"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__pki__subcmd__vouch__subcmd__add)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__pki__subcmd__vouch__subcmd__authorize)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__pki__subcmd__vouch__subcmd__list)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__pki__subcmd__vouch__subcmd__replay)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 5 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__sign)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__verify)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__help__subcmd__version)
            opts=""
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__inspect)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-domain --cert-grep --cert-file --certifications --dump-bad-signatures --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-domain)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-grep)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help list generate rotate import export delete password expire revoke userid subkey approvals"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__approvals)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help list update"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__approvals__subcmd__list)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-file --userid --email --pending --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__approvals__subcmd__update)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-file --userid --email --remove-all --remove-by --add-all --add-by --add-authenticated --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --remove-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --add-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__delete)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-file --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__expire)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-file --output --expiration --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --expiration)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__export)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-domain --cert-grep --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-domain)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-grep)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__generate)
            opts="-v -q -h --own-key --shared-key --name --email --userid --allow-non-canonical-userids --no-userids --cipher-suite --encryption-algorithm --signing-algorithm --profile --new-password-file --without-password --can-sign --cannot-sign --can-authenticate --cannot-authenticate --can-encrypt --cannot-encrypt --output --rev-cert --expiration --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --name)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cipher-suite)
                    COMPREPLY=($(compgen -W "rsa2k rsa3k rsa4k cv25519 cv448 mldsa65-ed25519 mldsa87-ed448" -- "${cur}"))
                    return 0
                    ;;
                --encryption-algorithm)
                    COMPREPLY=($(compgen -W "rsa2k rsa3k rsa4k elgamal2k elgamal3k cv25519 x25519 x448 nistp256 nistp384 nistp521 brainpoolp256 brainpoolp384 brainpoolp512 mlkem768-x25519 mlkem1024-x448" -- "${cur}"))
                    return 0
                    ;;
                --signing-algorithm)
                    COMPREPLY=($(compgen -W "rsa2k rsa3k rsa4k dsa2k dsa3k cv25519 ed25519 ed448 nistp256 nistp384 nistp521 brainpoolp256 brainpoolp384 brainpoolp512 mldsa65-ed25519 mldsa87-ed448 slhdsa128s slhdsa128f slhdsa256s" -- "${cur}"))
                    return 0
                    ;;
                --profile)
                    COMPREPLY=($(compgen -W "rfc9580 rfc4880" -- "${cur}"))
                    return 0
                    ;;
                --new-password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --can-encrypt)
                    COMPREPLY=($(compgen -W "transport storage universal" -- "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --rev-cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --expiration)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__import)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__list)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-domain --cert-grep --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-domain)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-grep)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__password)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-file --new-password-file --clear-password --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --new-password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__revoke)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-file --revoker --revoker-userid --revoker-email --revoker-file --reason --message --signature-notation --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --revoker)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --revoker-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --revoker-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --revoker-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --reason)
                    COMPREPLY=($(compgen -W "compromised superseded retired unspecified" -- "${cur}"))
                    return 0
                    ;;
                --message)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signature-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__rotate)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-file --own-key --shared-key --cipher-suite --profile --new-password-file --without-password --can-sign --cannot-sign --can-authenticate --cannot-authenticate --can-encrypt --cannot-encrypt --output --rev-cert --expiration --retire-in --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cipher-suite)
                    COMPREPLY=($(compgen -W "rsa2k rsa3k rsa4k cv25519 cv448 mldsa65-ed25519 mldsa87-ed448" -- "${cur}"))
                    return 0
                    ;;
                --profile)
                    COMPREPLY=($(compgen -W "rfc9580 rfc4880" -- "${cur}"))
                    return 0
                    ;;
                --new-password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --can-encrypt)
                    COMPREPLY=($(compgen -W "transport storage universal" -- "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --rev-cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --expiration)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --retire-in)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__subkey)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help add export delete password expire revoke bind"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__subkey__subcmd__add)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-file --cipher-suite --expiration --can-sign --can-authenticate --can-encrypt --new-password-file --without-password --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cipher-suite)
                    COMPREPLY=($(compgen -W "rsa2k rsa3k rsa4k cv25519 cv448 mldsa65-ed25519 mldsa87-ed448" -- "${cur}"))
                    return 0
                    ;;
                --expiration)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --can-encrypt)
                    COMPREPLY=($(compgen -W "transport storage universal" -- "${cur}"))
                    return 0
                    ;;
                --new-password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__subkey__subcmd__bind)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-file --key --creation-time --expiration --allow-broken-crypto --can-sign --cannot-sign --can-authenticate --cannot-authenticate --can-encrypt --cannot-encrypt --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --creation-time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --expiration)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --can-encrypt)
                    COMPREPLY=($(compgen -W "transport storage universal" -- "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__subkey__subcmd__delete)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-file --key --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__subkey__subcmd__expire)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-file --key --output --expiration --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --expiration)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__subkey__subcmd__export)
            opts="-v -q -h --cert --cert-userid --cert-email --key --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__subkey__subcmd__password)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-file --key --new-password-file --clear-password --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --new-password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__subkey__subcmd__revoke)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-file --revoker --revoker-userid --revoker-email --revoker-file --key --reason --message --signature-notation --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --revoker)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --revoker-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --revoker-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --revoker-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --reason)
                    COMPREPLY=($(compgen -W "compromised superseded retired unspecified" -- "${cur}"))
                    return 0
                    ;;
                --message)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signature-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__userid)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help add revoke"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__userid__subcmd__add)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-file --name --email --userid --allow-non-canonical-userids --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --name)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__key__subcmd__userid__subcmd__revoke)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-file --revoker --revoker-userid --revoker-email --revoker-file --userid --add-userid --userid-by-email --email --add-email --allow-non-canonical-userids --reason --message --signature-notation --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --revoker)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --revoker-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --revoker-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --revoker-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --add-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --userid-by-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --add-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --reason)
                    COMPREPLY=($(compgen -W "retired unspecified" -- "${cur}"))
                    return 0
                    ;;
                --message)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signature-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__keyring)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help list split merge filter"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__keyring__subcmd__filter)
            opts="-v -q -h --experimental --output --userid --name --email --domain --cert --key --prune-certs --to-cert --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --name)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --domain)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__keyring__subcmd__list)
            opts="-v -q -h --all-userids --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__keyring__subcmd__merge)
            opts="-v -q -h --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__keyring__subcmd__split)
            opts="-v -q -h --prefix --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --prefix)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__network)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help search keyserver wkd dane"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__network__subcmd__dane)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help search generate"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__network__subcmd__dane__subcmd__generate)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-file --all --domain --ttl --size-limit --type --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --domain)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --ttl)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --size-limit)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --type)
                    COMPREPLY=($(compgen -W "openpgp generic" -- "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__network__subcmd__dane__subcmd__search)
            opts="-v -q -h --all --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__network__subcmd__keyserver)
            opts="-v -q -h --server --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help search publish"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --server)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__network__subcmd__keyserver__subcmd__publish)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-domain --cert-file --server --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-domain)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --server)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__network__subcmd__keyserver__subcmd__search)
            opts="-v -q -h --output --all --server --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --server)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__network__subcmd__search)
            opts="-v -q -h --iterations --server --use-wkd --use-dane --output --all --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --iterations)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --server)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --use-wkd)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --use-dane)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__network__subcmd__wkd)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help search publish"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__network__subcmd__wkd__subcmd__publish)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-file --all --create --method --rsync --rsync-path --domain --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --method)
                    COMPREPLY=($(compgen -W "advanced direct" -- "${cur}"))
                    return 0
                    ;;
                --rsync-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --domain)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__network__subcmd__wkd__subcmd__search)
            opts="-v -q -h --all --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__packet)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help armor dearmor dump decrypt split join"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__packet__subcmd__armor)
            opts="-v -q -h --output --label --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --label)
                    COMPREPLY=($(compgen -W "auto message cert key sig file" -- "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__packet__subcmd__dearmor)
            opts="-v -q -h --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__packet__subcmd__decrypt)
            opts="-v -q -h --output --binary --recipient-file --session-key --dump-session-key --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --recipient-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --session-key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__packet__subcmd__dump)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-file --output --session-key --recipient-file --mpis --hex --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --session-key)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --recipient-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__packet__subcmd__join)
            opts="-v -q -h --output --label --binary --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --label)
                    COMPREPLY=($(compgen -W "auto message cert key sig file" -- "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__packet__subcmd__split)
            opts="-v -q -h --output --binary --output-prefix --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output-prefix)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__pki)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help authenticate lookup identify vouch link path"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__pki__subcmd__authenticate)
            opts="-v -q -h --cert --userid --email --show-paths --gossip --unusable --certification-network --amount --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --amount)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__pki__subcmd__identify)
            opts="-v -q -h --cert --show-paths --gossip --unusable --certification-network --amount --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --amount)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__pki__subcmd__link)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help add authorize retract list"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__pki__subcmd__link__subcmd__add)
            opts="-v -q -h --cert --cert-special --all --userid --add-userid --userid-by-email --email --add-email --allow-non-canonical-userids --amount --temporary --expiration --recreate --signature-notation --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-special)
                    COMPREPLY=($(compgen -W "public-directories keys.openpgp.org keys.mailvelope.com proton.me wkd dane autocrypt web" -- "${cur}"))
                    return 0
                    ;;
                --userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --add-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --userid-by-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --add-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --amount)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --expiration)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signature-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__pki__subcmd__link__subcmd__authorize)
            opts="-v -q -h --cert --cert-special --all --userid --add-userid --userid-by-email --email --add-email --allow-non-canonical-userids --amount --depth --domain --regex --unconstrained --expiration --recreate --signature-notation --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-special)
                    COMPREPLY=($(compgen -W "public-directories keys.openpgp.org keys.mailvelope.com proton.me wkd dane autocrypt web" -- "${cur}"))
                    return 0
                    ;;
                --userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --add-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --userid-by-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --add-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --amount)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --depth)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --domain)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --regex)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --expiration)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signature-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__pki__subcmd__link__subcmd__list)
            opts="-v -q -h --cert --cert-userid --cert-email --cert-domain --cert-grep --ca --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-domain)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-grep)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__pki__subcmd__link__subcmd__retract)
            opts="-v -q -h --signature-notation --recreate --cert --cert-special --all --userid --userid-by-email --email --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --signature-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-special)
                    COMPREPLY=($(compgen -W "public-directories keys.openpgp.org keys.mailvelope.com proton.me wkd dane autocrypt web" -- "${cur}"))
                    return 0
                    ;;
                --userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --userid-by-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__pki__subcmd__lookup)
            opts="-v -q -h --userid --email --show-paths --gossip --unusable --certification-network --amount --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --amount)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__pki__subcmd__path)
            opts="-v -q -h --userid --userid-by-email --email --certification-network --amount --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --userid-by-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --amount)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__pki__subcmd__vouch)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help add authorize list replay"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__pki__subcmd__vouch__subcmd__add)
            opts="-v -q -h --certifier --certifier-userid --certifier-email --certifier-file --certifier-self --cert --cert-file --all --userid --add-userid --userid-by-email --email --add-email --allow-non-canonical-userids --amount --expiration --local --non-revocable --signature-notation --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --certifier)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --certifier-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --certifier-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --certifier-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --add-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --userid-by-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --add-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --amount)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --expiration)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signature-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__pki__subcmd__vouch__subcmd__authorize)
            opts="-v -q -h --certifier --certifier-userid --certifier-email --certifier-file --certifier-self --cert --cert-file --all --userid --add-userid --userid-by-email --email --add-email --allow-non-canonical-userids --amount --depth --domain --regex --unconstrained --local --non-revocable --expiration --signature-notation --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --certifier)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --certifier-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --certifier-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --certifier-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --add-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --userid-by-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --add-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --amount)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --depth)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --domain)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --regex)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --expiration)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signature-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__pki__subcmd__vouch__subcmd__list)
            opts="-v -q -h --certifier --certifier-special --certifier-userid --certifier-email --certifier-file --certifier-self --cert --cert-userid --cert-email --cert-file --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --certifier)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --certifier-special)
                    COMPREPLY=($(compgen -W "public-directories keys.openpgp.org keys.mailvelope.com proton.me wkd dane autocrypt web" -- "${cur}"))
                    return 0
                    ;;
                --certifier-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --certifier-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --certifier-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__pki__subcmd__vouch__subcmd__replay)
            opts="-v -q -h --source --source-userid --source-email --source-file --target --target-userid --target-email --target-file --allow-dissimilar-userids --output --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 4 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --source)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --source-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --source-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --source-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --target)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --target-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --target-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --target-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__sign)
            opts="-v -q -h --output --binary --signature-file --message --cleartext --mode --append --notarize --merge --signer --signer-userid --signer-email --signer-file --signer-self --signature-notation --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signature-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --mode)
                    COMPREPLY=($(compgen -W "binary text" -- "${cur}"))
                    return 0
                    ;;
                --merge)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signature-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__verify)
            opts="-v -q -h --output --signature-file --message --cleartext --signatures --signer --signer-userid --signer-email --signer-domain --signer-file --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signature-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signatures)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer-userid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer-email)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer-domain)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --signer-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        sq__subcmd__version)
            opts="-v -q -h --cli-version --overwrite --home --key-store --cert-store --keyring --known-notation --time --policy-as-of --trust-root --password-file --verbose --quiet --batch --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cli-version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --home)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --key-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --cert-store)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --keyring)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --known-notation)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --policy-as-of)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trust-root)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --password-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
    esac
}

if [[ "${BASH_VERSINFO[0]}" -eq 4 && "${BASH_VERSINFO[1]}" -ge 4 || "${BASH_VERSINFO[0]}" -gt 4 ]]; then
    complete -F _sq -o nosort -o bashdefault -o default sq
else
    complete -F _sq -o bashdefault -o default sq
fi
