_jj-gh() {
    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="jj__gh"
                ;;
            jj__gh,completions)
                cmd="jj__gh__subcmd__completions"
                ;;
            jj__gh,debug)
                cmd="jj__gh__subcmd__debug"
                ;;
            jj__gh,help)
                cmd="jj__gh__subcmd__help"
                ;;
            jj__gh,pr)
                cmd="jj__gh__subcmd__pr"
                ;;
            jj__gh__subcmd__debug,auth)
                cmd="jj__gh__subcmd__debug__subcmd__auth"
                ;;
            jj__gh__subcmd__debug,config)
                cmd="jj__gh__subcmd__debug__subcmd__config"
                ;;
            jj__gh__subcmd__debug,help)
                cmd="jj__gh__subcmd__debug__subcmd__help"
                ;;
            jj__gh__subcmd__debug,pr-lookup)
                cmd="jj__gh__subcmd__debug__subcmd__pr__subcmd__lookup"
                ;;
            jj__gh__subcmd__debug,rev)
                cmd="jj__gh__subcmd__debug__subcmd__rev"
                ;;
            jj__gh__subcmd__debug__subcmd__help,auth)
                cmd="jj__gh__subcmd__debug__subcmd__help__subcmd__auth"
                ;;
            jj__gh__subcmd__debug__subcmd__help,config)
                cmd="jj__gh__subcmd__debug__subcmd__help__subcmd__config"
                ;;
            jj__gh__subcmd__debug__subcmd__help,help)
                cmd="jj__gh__subcmd__debug__subcmd__help__subcmd__help"
                ;;
            jj__gh__subcmd__debug__subcmd__help,pr-lookup)
                cmd="jj__gh__subcmd__debug__subcmd__help__subcmd__pr__subcmd__lookup"
                ;;
            jj__gh__subcmd__debug__subcmd__help,rev)
                cmd="jj__gh__subcmd__debug__subcmd__help__subcmd__rev"
                ;;
            jj__gh__subcmd__help,completions)
                cmd="jj__gh__subcmd__help__subcmd__completions"
                ;;
            jj__gh__subcmd__help,debug)
                cmd="jj__gh__subcmd__help__subcmd__debug"
                ;;
            jj__gh__subcmd__help,help)
                cmd="jj__gh__subcmd__help__subcmd__help"
                ;;
            jj__gh__subcmd__help,pr)
                cmd="jj__gh__subcmd__help__subcmd__pr"
                ;;
            jj__gh__subcmd__help__subcmd__debug,auth)
                cmd="jj__gh__subcmd__help__subcmd__debug__subcmd__auth"
                ;;
            jj__gh__subcmd__help__subcmd__debug,config)
                cmd="jj__gh__subcmd__help__subcmd__debug__subcmd__config"
                ;;
            jj__gh__subcmd__help__subcmd__debug,pr-lookup)
                cmd="jj__gh__subcmd__help__subcmd__debug__subcmd__pr__subcmd__lookup"
                ;;
            jj__gh__subcmd__help__subcmd__debug,rev)
                cmd="jj__gh__subcmd__help__subcmd__debug__subcmd__rev"
                ;;
            jj__gh__subcmd__help__subcmd__pr,auto-merge)
                cmd="jj__gh__subcmd__help__subcmd__pr__subcmd__auto__subcmd__merge"
                ;;
            jj__gh__subcmd__help__subcmd__pr,create)
                cmd="jj__gh__subcmd__help__subcmd__pr__subcmd__create"
                ;;
            jj__gh__subcmd__help__subcmd__pr,edit)
                cmd="jj__gh__subcmd__help__subcmd__pr__subcmd__edit"
                ;;
            jj__gh__subcmd__help__subcmd__pr,fetch)
                cmd="jj__gh__subcmd__help__subcmd__pr__subcmd__fetch"
                ;;
            jj__gh__subcmd__help__subcmd__pr,log)
                cmd="jj__gh__subcmd__help__subcmd__pr__subcmd__log"
                ;;
            jj__gh__subcmd__help__subcmd__pr,restack)
                cmd="jj__gh__subcmd__help__subcmd__pr__subcmd__restack"
                ;;
            jj__gh__subcmd__help__subcmd__pr,retry-failed)
                cmd="jj__gh__subcmd__help__subcmd__pr__subcmd__retry__subcmd__failed"
                ;;
            jj__gh__subcmd__help__subcmd__pr,url)
                cmd="jj__gh__subcmd__help__subcmd__pr__subcmd__url"
                ;;
            jj__gh__subcmd__pr,am)
                cmd="jj__gh__subcmd__pr__subcmd__auto__subcmd__merge"
                ;;
            jj__gh__subcmd__pr,auto-merge)
                cmd="jj__gh__subcmd__pr__subcmd__auto__subcmd__merge"
                ;;
            jj__gh__subcmd__pr,c)
                cmd="jj__gh__subcmd__pr__subcmd__create"
                ;;
            jj__gh__subcmd__pr,create)
                cmd="jj__gh__subcmd__pr__subcmd__create"
                ;;
            jj__gh__subcmd__pr,e)
                cmd="jj__gh__subcmd__pr__subcmd__edit"
                ;;
            jj__gh__subcmd__pr,edit)
                cmd="jj__gh__subcmd__pr__subcmd__edit"
                ;;
            jj__gh__subcmd__pr,f)
                cmd="jj__gh__subcmd__pr__subcmd__fetch"
                ;;
            jj__gh__subcmd__pr,fetch)
                cmd="jj__gh__subcmd__pr__subcmd__fetch"
                ;;
            jj__gh__subcmd__pr,help)
                cmd="jj__gh__subcmd__pr__subcmd__help"
                ;;
            jj__gh__subcmd__pr,l)
                cmd="jj__gh__subcmd__pr__subcmd__log"
                ;;
            jj__gh__subcmd__pr,log)
                cmd="jj__gh__subcmd__pr__subcmd__log"
                ;;
            jj__gh__subcmd__pr,rerun)
                cmd="jj__gh__subcmd__pr__subcmd__retry__subcmd__failed"
                ;;
            jj__gh__subcmd__pr,restack)
                cmd="jj__gh__subcmd__pr__subcmd__restack"
                ;;
            jj__gh__subcmd__pr,retry-failed)
                cmd="jj__gh__subcmd__pr__subcmd__retry__subcmd__failed"
                ;;
            jj__gh__subcmd__pr,rs)
                cmd="jj__gh__subcmd__pr__subcmd__restack"
                ;;
            jj__gh__subcmd__pr,url)
                cmd="jj__gh__subcmd__pr__subcmd__url"
                ;;
            jj__gh__subcmd__pr__subcmd__help,auto-merge)
                cmd="jj__gh__subcmd__pr__subcmd__help__subcmd__auto__subcmd__merge"
                ;;
            jj__gh__subcmd__pr__subcmd__help,create)
                cmd="jj__gh__subcmd__pr__subcmd__help__subcmd__create"
                ;;
            jj__gh__subcmd__pr__subcmd__help,edit)
                cmd="jj__gh__subcmd__pr__subcmd__help__subcmd__edit"
                ;;
            jj__gh__subcmd__pr__subcmd__help,fetch)
                cmd="jj__gh__subcmd__pr__subcmd__help__subcmd__fetch"
                ;;
            jj__gh__subcmd__pr__subcmd__help,help)
                cmd="jj__gh__subcmd__pr__subcmd__help__subcmd__help"
                ;;
            jj__gh__subcmd__pr__subcmd__help,log)
                cmd="jj__gh__subcmd__pr__subcmd__help__subcmd__log"
                ;;
            jj__gh__subcmd__pr__subcmd__help,restack)
                cmd="jj__gh__subcmd__pr__subcmd__help__subcmd__restack"
                ;;
            jj__gh__subcmd__pr__subcmd__help,retry-failed)
                cmd="jj__gh__subcmd__pr__subcmd__help__subcmd__retry__subcmd__failed"
                ;;
            jj__gh__subcmd__pr__subcmd__help,url)
                cmd="jj__gh__subcmd__pr__subcmd__help__subcmd__url"
                ;;
            *)
                ;;
        esac
    done

    case "${cmd}" in
        jj__gh)
            opts="-v -q -h -V --verbose --quiet --log-level --remote --upstream-remote --gh-askpass --askpass-timeout --help --version pr debug completions help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --log-level)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --upstream-remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gh-askpass)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --askpass-timeout)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        jj__subcmd__gh__subcmd__completions)
            opts="-v -q -h --jj-alias --subcommand --verbose --quiet --log-level --remote --upstream-remote --gh-askpass --askpass-timeout --help bash elvish fish powershell zsh"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --jj-alias)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --subcommand)
                    COMPREPLY=($(compgen -W "pr" -- "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --upstream-remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gh-askpass)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --askpass-timeout)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        jj__subcmd__gh__subcmd__debug)
            opts="-v -q -h --verbose --quiet --log-level --remote --upstream-remote --gh-askpass --askpass-timeout --help config auth rev pr-lookup help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --log-level)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --upstream-remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gh-askpass)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --askpass-timeout)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        jj__subcmd__gh__subcmd__debug__subcmd__auth)
            opts="-v -q -h --verbose --quiet --log-level --remote --upstream-remote --gh-askpass --askpass-timeout --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --log-level)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --upstream-remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gh-askpass)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --askpass-timeout)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        jj__subcmd__gh__subcmd__debug__subcmd__config)
            opts="-v -q -h --verbose --quiet --log-level --remote --upstream-remote --gh-askpass --askpass-timeout --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --log-level)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --upstream-remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gh-askpass)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --askpass-timeout)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        jj__subcmd__gh__subcmd__debug__subcmd__help)
            opts="config auth rev pr-lookup help"
            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
            ;;
        jj__subcmd__gh__subcmd__debug__subcmd__help__subcmd__auth)
            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
            ;;
        jj__subcmd__gh__subcmd__debug__subcmd__help__subcmd__config)
            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
            ;;
        jj__subcmd__gh__subcmd__debug__subcmd__help__subcmd__help)
            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
            ;;
        jj__subcmd__gh__subcmd__debug__subcmd__help__subcmd__pr__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
            ;;
        jj__subcmd__gh__subcmd__debug__subcmd__help__subcmd__rev)
            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
            ;;
        jj__subcmd__gh__subcmd__debug__subcmd__pr__subcmd__lookup)
            opts="-v -q -h --verbose --quiet --log-level --remote --upstream-remote --gh-askpass --askpass-timeout --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --log-level)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --upstream-remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gh-askpass)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --askpass-timeout)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        jj__subcmd__gh__subcmd__debug__subcmd__rev)
            opts="-v -q -h --verbose --quiet --log-level --remote --upstream-remote --gh-askpass --askpass-timeout --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --log-level)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --upstream-remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gh-askpass)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --askpass-timeout)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        jj__subcmd__gh__subcmd__help)
            opts="pr debug completions 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
            ;;
        jj__subcmd__gh__subcmd__help__subcmd__completions)
            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
            ;;
        jj__subcmd__gh__subcmd__help__subcmd__debug)
            opts="config auth rev pr-lookup"
            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
            ;;
        jj__subcmd__gh__subcmd__help__subcmd__debug__subcmd__auth)
            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
            ;;
        jj__subcmd__gh__subcmd__help__subcmd__debug__subcmd__config)
            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
            ;;
        jj__subcmd__gh__subcmd__help__subcmd__debug__subcmd__pr__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
            ;;
        jj__subcmd__gh__subcmd__help__subcmd__debug__subcmd__rev)
            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
            ;;
        jj__subcmd__gh__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
            ;;
        jj__subcmd__gh__subcmd__help__subcmd__pr)
            opts="auto-merge create edit fetch log restack retry-failed url"
            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
            ;;
        jj__subcmd__gh__subcmd__help__subcmd__pr__subcmd__auto__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
            ;;
        jj__subcmd__gh__subcmd__help__subcmd__pr__subcmd__create)
            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
            ;;
        jj__subcmd__gh__subcmd__help__subcmd__pr__subcmd__edit)
            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
            ;;
        jj__subcmd__gh__subcmd__help__subcmd__pr__subcmd__fetch)
            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
            ;;
        jj__subcmd__gh__subcmd__help__subcmd__pr__subcmd__log)
            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
            ;;
        jj__subcmd__gh__subcmd__help__subcmd__pr__subcmd__restack)
            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
            ;;
        jj__subcmd__gh__subcmd__help__subcmd__pr__subcmd__retry__subcmd__failed)
            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
            ;;
        jj__subcmd__gh__subcmd__help__subcmd__pr__subcmd__url)
            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
            ;;
        jj__subcmd__gh__subcmd__pr)
            opts="-v -q -h --verbose --quiet --log-level --remote --upstream-remote --gh-askpass --askpass-timeout --help auto-merge am create c edit e fetch f log l restack rs retry-failed rerun url help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --log-level)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --upstream-remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gh-askpass)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --askpass-timeout)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        jj__subcmd__gh__subcmd__pr__subcmd__auto__subcmd__merge)
            opts="-m -v -q -h --method --verbose --quiet --log-level --remote --upstream-remote --gh-askpass --askpass-timeout --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --method)
                    COMPREPLY=($(compgen -W "merge squash rebase" -- "${cur}"))
                    return 0
                    ;;
                -m)
                    COMPREPLY=($(compgen -W "merge squash rebase" -- "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --upstream-remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gh-askpass)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --askpass-timeout)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        jj__subcmd__gh__subcmd__pr__subcmd__create)
            opts="-T -e -v -q -h --base --draft --no-draft --auto-merge --no-auto-merge --auto-merge-method --template --template-file --no-template --pick-title --title-template --editor --no-edit --diffs --no-diffs --verbose --quiet --log-level --remote --upstream-remote --gh-askpass --askpass-timeout --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --base)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --auto-merge-method)
                    COMPREPLY=($(compgen -W "merge squash rebase" -- "${cur}"))
                    return 0
                    ;;
                --template)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -T)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --template-file)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --title-template)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --editor)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -e)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --upstream-remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gh-askpass)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --askpass-timeout)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        jj__subcmd__gh__subcmd__pr__subcmd__edit)
            opts="-f -e -v -q -h --force --editor --diffs --no-diffs --verbose --quiet --log-level --remote --upstream-remote --gh-askpass --askpass-timeout --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --editor)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -e)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --upstream-remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gh-askpass)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --askpass-timeout)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        jj__subcmd__gh__subcmd__pr__subcmd__fetch)
            opts="-T -f -v -q -h --template --force --verbose --quiet --log-level --remote --upstream-remote --gh-askpass --askpass-timeout --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --template)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -T)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --upstream-remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gh-askpass)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --askpass-timeout)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        jj__subcmd__gh__subcmd__pr__subcmd__help)
            opts="auto-merge create edit fetch log restack retry-failed url help"
            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
            ;;
        jj__subcmd__gh__subcmd__pr__subcmd__help__subcmd__auto__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
            ;;
        jj__subcmd__gh__subcmd__pr__subcmd__help__subcmd__create)
            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
            ;;
        jj__subcmd__gh__subcmd__pr__subcmd__help__subcmd__edit)
            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
            ;;
        jj__subcmd__gh__subcmd__pr__subcmd__help__subcmd__fetch)
            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
            ;;
        jj__subcmd__gh__subcmd__pr__subcmd__help__subcmd__help)
            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
            ;;
        jj__subcmd__gh__subcmd__pr__subcmd__help__subcmd__log)
            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
            ;;
        jj__subcmd__gh__subcmd__pr__subcmd__help__subcmd__restack)
            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
            ;;
        jj__subcmd__gh__subcmd__pr__subcmd__help__subcmd__retry__subcmd__failed)
            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
            ;;
        jj__subcmd__gh__subcmd__pr__subcmd__help__subcmd__url)
            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
            ;;
        jj__subcmd__gh__subcmd__pr__subcmd__log)
            opts="-T -v -q -h --nerdfonts --no-nerdfonts --verbose --quiet --log-level --remote --upstream-remote --gh-askpass --askpass-timeout --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                -T)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --upstream-remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gh-askpass)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --askpass-timeout)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        jj__subcmd__gh__subcmd__pr__subcmd__restack)
            opts="-T -v -q -h --dry-run --json --template --nerdfonts --no-nerdfonts --verbose --quiet --log-level --remote --upstream-remote --gh-askpass --askpass-timeout --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --template)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -T)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --upstream-remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gh-askpass)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --askpass-timeout)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        jj__subcmd__gh__subcmd__pr__subcmd__retry__subcmd__failed)
            opts="-v -q -h --all --cancel --cancel-timeout --verbose --quiet --log-level --remote --upstream-remote --gh-askpass --askpass-timeout --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --cancel-timeout)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --upstream-remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gh-askpass)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --askpass-timeout)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        jj__subcmd__gh__subcmd__pr__subcmd__url)
            opts="-v -q -h --remote --upstream-remote --verbose --quiet --log-level --gh-askpass --askpass-timeout --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --upstream-remote)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --log-level)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gh-askpass)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --askpass-timeout)
                    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 _jj-gh -o nosort -o bashdefault -o default jj-gh
else
    complete -F _jj-gh -o bashdefault -o default jj-gh
fi
