_aiken() {
    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="aiken"
                ;;
            aiken,add)
                cmd="aiken__subcmd__add"
                ;;
            aiken,address)
                cmd="aiken__subcmd__address"
                ;;
            aiken,b)
                cmd="aiken__subcmd__build"
                ;;
            aiken,bench)
                cmd="aiken__subcmd__bench"
                ;;
            aiken,blueprint)
                cmd="aiken__subcmd__blueprint"
                ;;
            aiken,build)
                cmd="aiken__subcmd__build"
                ;;
            aiken,c)
                cmd="aiken__subcmd__check"
                ;;
            aiken,check)
                cmd="aiken__subcmd__check"
                ;;
            aiken,completion)
                cmd="aiken__subcmd__completion"
                ;;
            aiken,docs)
                cmd="aiken__subcmd__docs"
                ;;
            aiken,export)
                cmd="aiken__subcmd__export"
                ;;
            aiken,fmt)
                cmd="aiken__subcmd__fmt"
                ;;
            aiken,help)
                cmd="aiken__subcmd__help"
                ;;
            aiken,lsp)
                cmd="aiken__subcmd__lsp"
                ;;
            aiken,new)
                cmd="aiken__subcmd__new"
                ;;
            aiken,packages)
                cmd="aiken__subcmd__packages"
                ;;
            aiken,tx)
                cmd="aiken__subcmd__tx"
                ;;
            aiken,uplc)
                cmd="aiken__subcmd__uplc"
                ;;
            aiken__subcmd__blueprint,address)
                cmd="aiken__subcmd__blueprint__subcmd__address"
                ;;
            aiken__subcmd__blueprint,apply)
                cmd="aiken__subcmd__blueprint__subcmd__apply"
                ;;
            aiken__subcmd__blueprint,convert)
                cmd="aiken__subcmd__blueprint__subcmd__convert"
                ;;
            aiken__subcmd__blueprint,hash)
                cmd="aiken__subcmd__blueprint__subcmd__hash"
                ;;
            aiken__subcmd__blueprint,help)
                cmd="aiken__subcmd__blueprint__subcmd__help"
                ;;
            aiken__subcmd__blueprint,policy)
                cmd="aiken__subcmd__blueprint__subcmd__policy"
                ;;
            aiken__subcmd__blueprint__subcmd__help,address)
                cmd="aiken__subcmd__blueprint__subcmd__help__subcmd__address"
                ;;
            aiken__subcmd__blueprint__subcmd__help,apply)
                cmd="aiken__subcmd__blueprint__subcmd__help__subcmd__apply"
                ;;
            aiken__subcmd__blueprint__subcmd__help,convert)
                cmd="aiken__subcmd__blueprint__subcmd__help__subcmd__convert"
                ;;
            aiken__subcmd__blueprint__subcmd__help,hash)
                cmd="aiken__subcmd__blueprint__subcmd__help__subcmd__hash"
                ;;
            aiken__subcmd__blueprint__subcmd__help,help)
                cmd="aiken__subcmd__blueprint__subcmd__help__subcmd__help"
                ;;
            aiken__subcmd__blueprint__subcmd__help,policy)
                cmd="aiken__subcmd__blueprint__subcmd__help__subcmd__policy"
                ;;
            aiken__subcmd__completion,bash)
                cmd="aiken__subcmd__completion__subcmd__bash"
                ;;
            aiken__subcmd__completion,fish)
                cmd="aiken__subcmd__completion__subcmd__fish"
                ;;
            aiken__subcmd__completion,help)
                cmd="aiken__subcmd__completion__subcmd__help"
                ;;
            aiken__subcmd__completion,zsh)
                cmd="aiken__subcmd__completion__subcmd__zsh"
                ;;
            aiken__subcmd__completion__subcmd__help,bash)
                cmd="aiken__subcmd__completion__subcmd__help__subcmd__bash"
                ;;
            aiken__subcmd__completion__subcmd__help,fish)
                cmd="aiken__subcmd__completion__subcmd__help__subcmd__fish"
                ;;
            aiken__subcmd__completion__subcmd__help,help)
                cmd="aiken__subcmd__completion__subcmd__help__subcmd__help"
                ;;
            aiken__subcmd__completion__subcmd__help,zsh)
                cmd="aiken__subcmd__completion__subcmd__help__subcmd__zsh"
                ;;
            aiken__subcmd__help,add)
                cmd="aiken__subcmd__help__subcmd__add"
                ;;
            aiken__subcmd__help,address)
                cmd="aiken__subcmd__help__subcmd__address"
                ;;
            aiken__subcmd__help,bench)
                cmd="aiken__subcmd__help__subcmd__bench"
                ;;
            aiken__subcmd__help,blueprint)
                cmd="aiken__subcmd__help__subcmd__blueprint"
                ;;
            aiken__subcmd__help,build)
                cmd="aiken__subcmd__help__subcmd__build"
                ;;
            aiken__subcmd__help,check)
                cmd="aiken__subcmd__help__subcmd__check"
                ;;
            aiken__subcmd__help,completion)
                cmd="aiken__subcmd__help__subcmd__completion"
                ;;
            aiken__subcmd__help,docs)
                cmd="aiken__subcmd__help__subcmd__docs"
                ;;
            aiken__subcmd__help,export)
                cmd="aiken__subcmd__help__subcmd__export"
                ;;
            aiken__subcmd__help,fmt)
                cmd="aiken__subcmd__help__subcmd__fmt"
                ;;
            aiken__subcmd__help,help)
                cmd="aiken__subcmd__help__subcmd__help"
                ;;
            aiken__subcmd__help,lsp)
                cmd="aiken__subcmd__help__subcmd__lsp"
                ;;
            aiken__subcmd__help,new)
                cmd="aiken__subcmd__help__subcmd__new"
                ;;
            aiken__subcmd__help,packages)
                cmd="aiken__subcmd__help__subcmd__packages"
                ;;
            aiken__subcmd__help,tx)
                cmd="aiken__subcmd__help__subcmd__tx"
                ;;
            aiken__subcmd__help,uplc)
                cmd="aiken__subcmd__help__subcmd__uplc"
                ;;
            aiken__subcmd__help__subcmd__blueprint,address)
                cmd="aiken__subcmd__help__subcmd__blueprint__subcmd__address"
                ;;
            aiken__subcmd__help__subcmd__blueprint,apply)
                cmd="aiken__subcmd__help__subcmd__blueprint__subcmd__apply"
                ;;
            aiken__subcmd__help__subcmd__blueprint,convert)
                cmd="aiken__subcmd__help__subcmd__blueprint__subcmd__convert"
                ;;
            aiken__subcmd__help__subcmd__blueprint,hash)
                cmd="aiken__subcmd__help__subcmd__blueprint__subcmd__hash"
                ;;
            aiken__subcmd__help__subcmd__blueprint,policy)
                cmd="aiken__subcmd__help__subcmd__blueprint__subcmd__policy"
                ;;
            aiken__subcmd__help__subcmd__completion,bash)
                cmd="aiken__subcmd__help__subcmd__completion__subcmd__bash"
                ;;
            aiken__subcmd__help__subcmd__completion,fish)
                cmd="aiken__subcmd__help__subcmd__completion__subcmd__fish"
                ;;
            aiken__subcmd__help__subcmd__completion,zsh)
                cmd="aiken__subcmd__help__subcmd__completion__subcmd__zsh"
                ;;
            aiken__subcmd__help__subcmd__packages,add)
                cmd="aiken__subcmd__help__subcmd__packages__subcmd__add"
                ;;
            aiken__subcmd__help__subcmd__packages,clear-cache)
                cmd="aiken__subcmd__help__subcmd__packages__subcmd__clear__subcmd__cache"
                ;;
            aiken__subcmd__help__subcmd__packages,upgrade)
                cmd="aiken__subcmd__help__subcmd__packages__subcmd__upgrade"
                ;;
            aiken__subcmd__help__subcmd__tx,simulate)
                cmd="aiken__subcmd__help__subcmd__tx__subcmd__simulate"
                ;;
            aiken__subcmd__help__subcmd__uplc,decode)
                cmd="aiken__subcmd__help__subcmd__uplc__subcmd__decode"
                ;;
            aiken__subcmd__help__subcmd__uplc,encode)
                cmd="aiken__subcmd__help__subcmd__uplc__subcmd__encode"
                ;;
            aiken__subcmd__help__subcmd__uplc,eval)
                cmd="aiken__subcmd__help__subcmd__uplc__subcmd__eval"
                ;;
            aiken__subcmd__help__subcmd__uplc,fmt)
                cmd="aiken__subcmd__help__subcmd__uplc__subcmd__fmt"
                ;;
            aiken__subcmd__help__subcmd__uplc,shrink)
                cmd="aiken__subcmd__help__subcmd__uplc__subcmd__shrink"
                ;;
            aiken__subcmd__packages,add)
                cmd="aiken__subcmd__packages__subcmd__add"
                ;;
            aiken__subcmd__packages,clear-cache)
                cmd="aiken__subcmd__packages__subcmd__clear__subcmd__cache"
                ;;
            aiken__subcmd__packages,help)
                cmd="aiken__subcmd__packages__subcmd__help"
                ;;
            aiken__subcmd__packages,upgrade)
                cmd="aiken__subcmd__packages__subcmd__upgrade"
                ;;
            aiken__subcmd__packages__subcmd__help,add)
                cmd="aiken__subcmd__packages__subcmd__help__subcmd__add"
                ;;
            aiken__subcmd__packages__subcmd__help,clear-cache)
                cmd="aiken__subcmd__packages__subcmd__help__subcmd__clear__subcmd__cache"
                ;;
            aiken__subcmd__packages__subcmd__help,help)
                cmd="aiken__subcmd__packages__subcmd__help__subcmd__help"
                ;;
            aiken__subcmd__packages__subcmd__help,upgrade)
                cmd="aiken__subcmd__packages__subcmd__help__subcmd__upgrade"
                ;;
            aiken__subcmd__tx,help)
                cmd="aiken__subcmd__tx__subcmd__help"
                ;;
            aiken__subcmd__tx,simulate)
                cmd="aiken__subcmd__tx__subcmd__simulate"
                ;;
            aiken__subcmd__tx__subcmd__help,help)
                cmd="aiken__subcmd__tx__subcmd__help__subcmd__help"
                ;;
            aiken__subcmd__tx__subcmd__help,simulate)
                cmd="aiken__subcmd__tx__subcmd__help__subcmd__simulate"
                ;;
            aiken__subcmd__uplc,decode)
                cmd="aiken__subcmd__uplc__subcmd__decode"
                ;;
            aiken__subcmd__uplc,encode)
                cmd="aiken__subcmd__uplc__subcmd__encode"
                ;;
            aiken__subcmd__uplc,eval)
                cmd="aiken__subcmd__uplc__subcmd__eval"
                ;;
            aiken__subcmd__uplc,fmt)
                cmd="aiken__subcmd__uplc__subcmd__fmt"
                ;;
            aiken__subcmd__uplc,help)
                cmd="aiken__subcmd__uplc__subcmd__help"
                ;;
            aiken__subcmd__uplc,shrink)
                cmd="aiken__subcmd__uplc__subcmd__shrink"
                ;;
            aiken__subcmd__uplc__subcmd__help,decode)
                cmd="aiken__subcmd__uplc__subcmd__help__subcmd__decode"
                ;;
            aiken__subcmd__uplc__subcmd__help,encode)
                cmd="aiken__subcmd__uplc__subcmd__help__subcmd__encode"
                ;;
            aiken__subcmd__uplc__subcmd__help,eval)
                cmd="aiken__subcmd__uplc__subcmd__help__subcmd__eval"
                ;;
            aiken__subcmd__uplc__subcmd__help,fmt)
                cmd="aiken__subcmd__uplc__subcmd__help__subcmd__fmt"
                ;;
            aiken__subcmd__uplc__subcmd__help,help)
                cmd="aiken__subcmd__uplc__subcmd__help__subcmd__help"
                ;;
            aiken__subcmd__uplc__subcmd__help,shrink)
                cmd="aiken__subcmd__uplc__subcmd__help__subcmd__shrink"
                ;;
            *)
                ;;
        esac
    done

    case "${cmd}" in
        aiken)
            opts="-h --help new fmt export build b address check c docs add bench blueprint packages tx uplc completion lsp help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 1 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        aiken__subcmd__add)
            opts="-h --version --overwrite --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        aiken__subcmd__address)
            opts="-i -m -v -h --in --module --validator --delegated-to --mainnet --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --in)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -i)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --module)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -m)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --validator)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -v)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --delegated-to)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        aiken__subcmd__bench)
            opts="-m -e -f -t -h --seed --max-size --match-benchmarks --exact-match --trace-filter --trace-level --plain-numbers --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --seed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --match-benchmarks)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -m)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trace-filter)
                    COMPREPLY=($(compgen -W "user-defined compiler-generated all" -- "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -W "user-defined compiler-generated all" -- "${cur}"))
                    return 0
                    ;;
                --trace-level)
                    COMPREPLY=($(compgen -W "silent compact verbose" -- "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -W "silent compact verbose" -- "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        aiken__subcmd__blueprint)
            opts="-h --help address policy hash apply convert 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
            ;;
        aiken__subcmd__blueprint__subcmd__address)
            opts="-i -m -v -h --in --module --validator --delegated-to --mainnet --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --in)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -i)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --module)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -m)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --validator)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -v)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --delegated-to)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        aiken__subcmd__blueprint__subcmd__apply)
            opts="-i -o -m -v -h --in --out --module --validator --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --in)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -i)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --out)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --module)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -m)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --validator)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -v)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        aiken__subcmd__blueprint__subcmd__convert)
            opts="-m -v -h --module --validator --to --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --module)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -m)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --validator)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -v)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --to)
                    COMPREPLY=($(compgen -W "cardano-cli" -- "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        aiken__subcmd__blueprint__subcmd__hash)
            opts="-i -m -v -h --in --module --validator --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --in)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -i)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --module)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -m)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --validator)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -v)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        aiken__subcmd__blueprint__subcmd__help)
            opts="address policy hash apply convert 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
            ;;
        aiken__subcmd__blueprint__subcmd__help__subcmd__address)
            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
            ;;
        aiken__subcmd__blueprint__subcmd__help__subcmd__apply)
            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
            ;;
        aiken__subcmd__blueprint__subcmd__help__subcmd__convert)
            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
            ;;
        aiken__subcmd__blueprint__subcmd__help__subcmd__hash)
            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
            ;;
        aiken__subcmd__blueprint__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
            ;;
        aiken__subcmd__blueprint__subcmd__help__subcmd__policy)
            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
            ;;
        aiken__subcmd__blueprint__subcmd__policy)
            opts="-i -m -v -h --in --module --validator --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --in)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -i)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --module)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -m)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --validator)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -v)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        aiken__subcmd__build)
            opts="-D -S -w -u -o -f -t -I -h --deny --silent --watch --uplc --env --out --trace-filter --trace-level --include-all-types --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --env)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --out)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trace-filter)
                    COMPREPLY=($(compgen -W "user-defined compiler-generated all" -- "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -W "user-defined compiler-generated all" -- "${cur}"))
                    return 0
                    ;;
                --trace-level)
                    COMPREPLY=($(compgen -W "silent compact verbose" -- "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -W "silent compact verbose" -- "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        aiken__subcmd__check)
            opts="-D -S -s -P -m -e -f -t -h --deny --silent --skip-tests --debug --show-json-schema --watch --seed --max-success --property-coverage --match-tests --exact-match --env --trace-filter --trace-level --plain-numbers --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --seed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-success)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --property-coverage)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -P)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --match-tests)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -m)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --env)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trace-filter)
                    COMPREPLY=($(compgen -W "user-defined compiler-generated all" -- "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -W "user-defined compiler-generated all" -- "${cur}"))
                    return 0
                    ;;
                --trace-level)
                    COMPREPLY=($(compgen -W "silent compact verbose" -- "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -W "silent compact verbose" -- "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        aiken__subcmd__completion)
            opts="-h --help bash zsh fish 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
            ;;
        aiken__subcmd__completion__subcmd__bash)
            opts="-i -h --install --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
            ;;
        aiken__subcmd__completion__subcmd__fish)
            opts="-i -h --install --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
            ;;
        aiken__subcmd__completion__subcmd__help)
            opts="bash zsh fish 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
            ;;
        aiken__subcmd__completion__subcmd__help__subcmd__bash)
            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
            ;;
        aiken__subcmd__completion__subcmd__help__subcmd__fish)
            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
            ;;
        aiken__subcmd__completion__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
            ;;
        aiken__subcmd__completion__subcmd__help__subcmd__zsh)
            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
            ;;
        aiken__subcmd__completion__subcmd__zsh)
            opts="-i -h --install --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
            ;;
        aiken__subcmd__docs)
            opts="-D -S -w -o -h --deny --silent --watch --include-dependencies --destination --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --destination)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        aiken__subcmd__export)
            opts="-m -n -f -t -h --module --name --trace-filter --trace-level --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --module)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -m)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --name)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -n)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --trace-filter)
                    COMPREPLY=($(compgen -W "user-defined compiler-generated all" -- "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -W "user-defined compiler-generated all" -- "${cur}"))
                    return 0
                    ;;
                --trace-level)
                    COMPREPLY=($(compgen -W "silent compact verbose" -- "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -W "silent compact verbose" -- "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        aiken__subcmd__fmt)
            opts="-h --stdin --check --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
            ;;
        aiken__subcmd__help)
            opts="new fmt export build address check docs add bench blueprint packages tx uplc completion lsp 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
            ;;
        aiken__subcmd__help__subcmd__add)
            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
            ;;
        aiken__subcmd__help__subcmd__address)
            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
            ;;
        aiken__subcmd__help__subcmd__bench)
            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
            ;;
        aiken__subcmd__help__subcmd__blueprint)
            opts="address policy hash apply convert"
            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
            ;;
        aiken__subcmd__help__subcmd__blueprint__subcmd__address)
            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
            ;;
        aiken__subcmd__help__subcmd__blueprint__subcmd__apply)
            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
            ;;
        aiken__subcmd__help__subcmd__blueprint__subcmd__convert)
            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
            ;;
        aiken__subcmd__help__subcmd__blueprint__subcmd__hash)
            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
            ;;
        aiken__subcmd__help__subcmd__blueprint__subcmd__policy)
            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
            ;;
        aiken__subcmd__help__subcmd__build)
            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
            ;;
        aiken__subcmd__help__subcmd__check)
            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
            ;;
        aiken__subcmd__help__subcmd__completion)
            opts="bash zsh fish"
            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
            ;;
        aiken__subcmd__help__subcmd__completion__subcmd__bash)
            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
            ;;
        aiken__subcmd__help__subcmd__completion__subcmd__fish)
            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
            ;;
        aiken__subcmd__help__subcmd__completion__subcmd__zsh)
            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
            ;;
        aiken__subcmd__help__subcmd__docs)
            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
            ;;
        aiken__subcmd__help__subcmd__export)
            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
            ;;
        aiken__subcmd__help__subcmd__fmt)
            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
            ;;
        aiken__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
            ;;
        aiken__subcmd__help__subcmd__lsp)
            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
            ;;
        aiken__subcmd__help__subcmd__new)
            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
            ;;
        aiken__subcmd__help__subcmd__packages)
            opts="add upgrade clear-cache"
            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
            ;;
        aiken__subcmd__help__subcmd__packages__subcmd__add)
            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
            ;;
        aiken__subcmd__help__subcmd__packages__subcmd__clear__subcmd__cache)
            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
            ;;
        aiken__subcmd__help__subcmd__packages__subcmd__upgrade)
            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
            ;;
        aiken__subcmd__help__subcmd__tx)
            opts="simulate"
            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
            ;;
        aiken__subcmd__help__subcmd__tx__subcmd__simulate)
            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
            ;;
        aiken__subcmd__help__subcmd__uplc)
            opts="fmt eval encode decode shrink"
            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
            ;;
        aiken__subcmd__help__subcmd__uplc__subcmd__decode)
            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
            ;;
        aiken__subcmd__help__subcmd__uplc__subcmd__encode)
            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
            ;;
        aiken__subcmd__help__subcmd__uplc__subcmd__eval)
            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
            ;;
        aiken__subcmd__help__subcmd__uplc__subcmd__fmt)
            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
            ;;
        aiken__subcmd__help__subcmd__uplc__subcmd__shrink)
            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
            ;;
        aiken__subcmd__lsp)
            opts="-h --stdio --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
            ;;
        aiken__subcmd__new)
            opts="-l -h --lib --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
            ;;
        aiken__subcmd__packages)
            opts="-h --help add upgrade clear-cache 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
            ;;
        aiken__subcmd__packages__subcmd__add)
            opts="-h --version --overwrite --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        aiken__subcmd__packages__subcmd__clear__subcmd__cache)
            opts="-h --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
            ;;
        aiken__subcmd__packages__subcmd__help)
            opts="add upgrade clear-cache 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
            ;;
        aiken__subcmd__packages__subcmd__help__subcmd__add)
            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
            ;;
        aiken__subcmd__packages__subcmd__help__subcmd__clear__subcmd__cache)
            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
            ;;
        aiken__subcmd__packages__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
            ;;
        aiken__subcmd__packages__subcmd__help__subcmd__upgrade)
            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
            ;;
        aiken__subcmd__packages__subcmd__upgrade)
            opts="-h --version --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        aiken__subcmd__tx)
            opts="-h --help simulate 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
            ;;
        aiken__subcmd__tx__subcmd__help)
            opts="simulate 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
            ;;
        aiken__subcmd__tx__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
            ;;
        aiken__subcmd__tx__subcmd__help__subcmd__simulate)
            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
            ;;
        aiken__subcmd__tx__subcmd__simulate)
            opts="-c -s -h --cbor --slot-length --zero-time --zero-slot --blueprint --script-override --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --slot-length)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --zero-time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --zero-slot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --blueprint)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --script-override)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        aiken__subcmd__uplc)
            opts="-h --help fmt eval encode decode shrink 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
            ;;
        aiken__subcmd__uplc__subcmd__decode)
            opts="-c -h --from --cbor --hex --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --from)
                    COMPREPLY=($(compgen -W "name named-debruijn debruijn" -- "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        aiken__subcmd__uplc__subcmd__encode)
            opts="-c -h --to --cbor --hex --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --to)
                    COMPREPLY=($(compgen -W "name named-debruijn debruijn" -- "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        aiken__subcmd__uplc__subcmd__eval)
            opts="-f -c -d -h --flat --cbor --debug --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
            ;;
        aiken__subcmd__uplc__subcmd__fmt)
            opts="-p -h --print --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
            ;;
        aiken__subcmd__uplc__subcmd__help)
            opts="fmt eval encode decode shrink 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
            ;;
        aiken__subcmd__uplc__subcmd__help__subcmd__decode)
            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
            ;;
        aiken__subcmd__uplc__subcmd__help__subcmd__encode)
            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
            ;;
        aiken__subcmd__uplc__subcmd__help__subcmd__eval)
            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
            ;;
        aiken__subcmd__uplc__subcmd__help__subcmd__fmt)
            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
            ;;
        aiken__subcmd__uplc__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
            ;;
        aiken__subcmd__uplc__subcmd__help__subcmd__shrink)
            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
            ;;
        aiken__subcmd__uplc__subcmd__shrink)
            opts="-c -h --from --to --cbor --hex --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --from)
                    COMPREPLY=($(compgen -W "name named-debruijn debruijn" -- "${cur}"))
                    return 0
                    ;;
                --to)
                    COMPREPLY=($(compgen -W "name named-debruijn debruijn" -- "${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 _aiken -o nosort -o bashdefault -o default aiken
else
    complete -F _aiken -o bashdefault -o default aiken
fi
