_wasm-tools() {
    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="wasm__tools"
                ;;
            wasm__tools,addr2line)
                cmd="wasm__tools__addr2line"
                ;;
            wasm__tools,completion)
                cmd="wasm__tools__completion"
                ;;
            wasm__tools,component)
                cmd="wasm__tools__component"
                ;;
            wasm__tools,compose)
                cmd="wasm__tools__compose"
                ;;
            wasm__tools,demangle)
                cmd="wasm__tools__demangle"
                ;;
            wasm__tools,dump)
                cmd="wasm__tools__dump"
                ;;
            wasm__tools,help)
                cmd="wasm__tools__help"
                ;;
            wasm__tools,json-from-wast)
                cmd="wasm__tools__json__from__wast"
                ;;
            wasm__tools,metadata)
                cmd="wasm__tools__metadata"
                ;;
            wasm__tools,mutate)
                cmd="wasm__tools__mutate"
                ;;
            wasm__tools,objdump)
                cmd="wasm__tools__objdump"
                ;;
            wasm__tools,parse)
                cmd="wasm__tools__parse"
                ;;
            wasm__tools,print)
                cmd="wasm__tools__print"
                ;;
            wasm__tools,shrink)
                cmd="wasm__tools__shrink"
                ;;
            wasm__tools,smith)
                cmd="wasm__tools__smith"
                ;;
            wasm__tools,strip)
                cmd="wasm__tools__strip"
                ;;
            wasm__tools,validate)
                cmd="wasm__tools__validate"
                ;;
            wasm__tools,wast)
                cmd="wasm__tools__wast"
                ;;
            wasm__tools,wit-dylib)
                cmd="wasm__tools__wit__dylib"
                ;;
            wasm__tools,wit-smith)
                cmd="wasm__tools__wit__smith"
                ;;
            wasm__tools__component,embed)
                cmd="wasm__tools__component__embed"
                ;;
            wasm__tools__component,help)
                cmd="wasm__tools__component__help"
                ;;
            wasm__tools__component,link)
                cmd="wasm__tools__component__link"
                ;;
            wasm__tools__component,new)
                cmd="wasm__tools__component__new"
                ;;
            wasm__tools__component,semver-check)
                cmd="wasm__tools__component__semver__check"
                ;;
            wasm__tools__component,targets)
                cmd="wasm__tools__component__targets"
                ;;
            wasm__tools__component,unbundle)
                cmd="wasm__tools__component__unbundle"
                ;;
            wasm__tools__component,wit)
                cmd="wasm__tools__component__wit"
                ;;
            wasm__tools__component__help,embed)
                cmd="wasm__tools__component__help__embed"
                ;;
            wasm__tools__component__help,help)
                cmd="wasm__tools__component__help__help"
                ;;
            wasm__tools__component__help,link)
                cmd="wasm__tools__component__help__link"
                ;;
            wasm__tools__component__help,new)
                cmd="wasm__tools__component__help__new"
                ;;
            wasm__tools__component__help,semver-check)
                cmd="wasm__tools__component__help__semver__check"
                ;;
            wasm__tools__component__help,targets)
                cmd="wasm__tools__component__help__targets"
                ;;
            wasm__tools__component__help,unbundle)
                cmd="wasm__tools__component__help__unbundle"
                ;;
            wasm__tools__component__help,wit)
                cmd="wasm__tools__component__help__wit"
                ;;
            wasm__tools__help,addr2line)
                cmd="wasm__tools__help__addr2line"
                ;;
            wasm__tools__help,completion)
                cmd="wasm__tools__help__completion"
                ;;
            wasm__tools__help,component)
                cmd="wasm__tools__help__component"
                ;;
            wasm__tools__help,compose)
                cmd="wasm__tools__help__compose"
                ;;
            wasm__tools__help,demangle)
                cmd="wasm__tools__help__demangle"
                ;;
            wasm__tools__help,dump)
                cmd="wasm__tools__help__dump"
                ;;
            wasm__tools__help,help)
                cmd="wasm__tools__help__help"
                ;;
            wasm__tools__help,json-from-wast)
                cmd="wasm__tools__help__json__from__wast"
                ;;
            wasm__tools__help,metadata)
                cmd="wasm__tools__help__metadata"
                ;;
            wasm__tools__help,mutate)
                cmd="wasm__tools__help__mutate"
                ;;
            wasm__tools__help,objdump)
                cmd="wasm__tools__help__objdump"
                ;;
            wasm__tools__help,parse)
                cmd="wasm__tools__help__parse"
                ;;
            wasm__tools__help,print)
                cmd="wasm__tools__help__print"
                ;;
            wasm__tools__help,shrink)
                cmd="wasm__tools__help__shrink"
                ;;
            wasm__tools__help,smith)
                cmd="wasm__tools__help__smith"
                ;;
            wasm__tools__help,strip)
                cmd="wasm__tools__help__strip"
                ;;
            wasm__tools__help,validate)
                cmd="wasm__tools__help__validate"
                ;;
            wasm__tools__help,wast)
                cmd="wasm__tools__help__wast"
                ;;
            wasm__tools__help,wit-dylib)
                cmd="wasm__tools__help__wit__dylib"
                ;;
            wasm__tools__help,wit-smith)
                cmd="wasm__tools__help__wit__smith"
                ;;
            wasm__tools__help__component,embed)
                cmd="wasm__tools__help__component__embed"
                ;;
            wasm__tools__help__component,link)
                cmd="wasm__tools__help__component__link"
                ;;
            wasm__tools__help__component,new)
                cmd="wasm__tools__help__component__new"
                ;;
            wasm__tools__help__component,semver-check)
                cmd="wasm__tools__help__component__semver__check"
                ;;
            wasm__tools__help__component,targets)
                cmd="wasm__tools__help__component__targets"
                ;;
            wasm__tools__help__component,unbundle)
                cmd="wasm__tools__help__component__unbundle"
                ;;
            wasm__tools__help__component,wit)
                cmd="wasm__tools__help__component__wit"
                ;;
            wasm__tools__help__metadata,add)
                cmd="wasm__tools__help__metadata__add"
                ;;
            wasm__tools__help__metadata,show)
                cmd="wasm__tools__help__metadata__show"
                ;;
            wasm__tools__metadata,add)
                cmd="wasm__tools__metadata__add"
                ;;
            wasm__tools__metadata,help)
                cmd="wasm__tools__metadata__help"
                ;;
            wasm__tools__metadata,show)
                cmd="wasm__tools__metadata__show"
                ;;
            wasm__tools__metadata__help,add)
                cmd="wasm__tools__metadata__help__add"
                ;;
            wasm__tools__metadata__help,help)
                cmd="wasm__tools__metadata__help__help"
                ;;
            wasm__tools__metadata__help,show)
                cmd="wasm__tools__metadata__help__show"
                ;;
            *)
                ;;
        esac
    done

    case "${cmd}" in
        wasm__tools)
            opts="-h -V --help --version parse validate print smith shrink mutate dump objdump strip compose demangle component metadata wit-smith wit-dylib addr2line completion json-from-wast wast 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
            ;;
        wasm__tools__addr2line)
            opts="-g -o -v -h --generate-dwarf --output --verbose --color --code-section-relative --help [INPUT] [ADDRESSES]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --generate-dwarf)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__completion)
            opts="-v -h --verbose --color --help bash elvish fish powershell zsh"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__component)
            opts="-h --help new wit embed targets link semver-check unbundle 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
            ;;
        wasm__tools__component__embed)
            opts="-g -o -v -w -t -h --features --all-features --generate-dwarf --output --verbose --color --encoding --world --dummy --dummy-names --async-callback --async-stackful --wat --only-custom --help <WIT> [INPUT]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --features)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --generate-dwarf)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --encoding)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --world)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --dummy-names)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__component__help)
            opts="new wit embed targets link semver-check unbundle 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
            ;;
        wasm__tools__component__help__embed)
            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
            ;;
        wasm__tools__component__help__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
            ;;
        wasm__tools__component__help__link)
            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
            ;;
        wasm__tools__component__help__new)
            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
            ;;
        wasm__tools__component__help__semver__check)
            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
            ;;
        wasm__tools__component__help__targets)
            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
            ;;
        wasm__tools__component__help__unbundle)
            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
            ;;
        wasm__tools__component__help__wit)
            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
            ;;
        wasm__tools__component__link)
            opts="-o -v -t -h --dl-openable --adapt --stack-size --output --verbose --color --skip-validation --validate --wat --stub-missing-functions --use-built-in-libdl --merge-imports-based-on-semver --debug-names --help [[NAME=]MODULE]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --dl-openable)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --adapt)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --stack-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --validate)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --merge-imports-based-on-semver)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --debug-names)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__component__new)
            opts="-g -o -v -t -h --adapt --import-name --generate-dwarf --output --verbose --color --skip-validation --wat --realloc-via-memory-grow --merge-imports-based-on-semver --reject-legacy-names --help [INPUT]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --adapt)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --import-name)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --generate-dwarf)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --merge-imports-based-on-semver)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__component__semver__check)
            opts="-v -h --verbose --color --features --all-features --prev --new --help <WIT>"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --features)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --prev)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --new)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__component__targets)
            opts="-v -w -h --verbose --color --features --all-features --world --help <WIT> [INPUT]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --features)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --world)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__component__unbundle)
            opts="-g -o -v -t -h --generate-dwarf --output --verbose --color --module-dir --threshold --wat --help [INPUT]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --generate-dwarf)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --module-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --threshold)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__component__wit)
            opts="-v -o -w -t -j -h --verbose --color --output --wasm --wat --no-docs --out-dir --skip-validation --json --importize --importize-out-world-name --importize-world --exportize --exportize-out-world-name --exportize-import --exportize-world --merge-world-imports-based-on-semver --generate-nominal-type-ids --features --all-features --help [INPUT]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --out-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --importize-out-world-name)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --importize-world)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --exportize-out-world-name)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --exportize-import)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --exportize-world)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --merge-world-imports-based-on-semver)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --generate-nominal-type-ids)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --features)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__compose)
            opts="-v -o -c -d -p -t -h -V --verbose --color --output --config --definitions --search-path --skip-validation --no-imports --wat --help --version <COMPONENT>"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --config)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --definitions)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -d)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --search-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -p)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__demangle)
            opts="-o -v -t -h --output --verbose --color --wat --help [INPUT]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__dump)
            opts="-o -v -h --output --verbose --color --help [INPUT]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__help)
            opts="parse validate print smith shrink mutate dump objdump strip compose demangle component metadata wit-smith wit-dylib addr2line completion json-from-wast wast 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
            ;;
        wasm__tools__help__addr2line)
            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
            ;;
        wasm__tools__help__completion)
            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
            ;;
        wasm__tools__help__component)
            opts="new wit embed targets link semver-check unbundle"
            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
            ;;
        wasm__tools__help__component__embed)
            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
            ;;
        wasm__tools__help__component__link)
            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
            ;;
        wasm__tools__help__component__new)
            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
            ;;
        wasm__tools__help__component__semver__check)
            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
            ;;
        wasm__tools__help__component__targets)
            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
            ;;
        wasm__tools__help__component__unbundle)
            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
            ;;
        wasm__tools__help__component__wit)
            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
            ;;
        wasm__tools__help__compose)
            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
            ;;
        wasm__tools__help__demangle)
            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
            ;;
        wasm__tools__help__dump)
            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
            ;;
        wasm__tools__help__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
            ;;
        wasm__tools__help__json__from__wast)
            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
            ;;
        wasm__tools__help__metadata)
            opts="show add"
            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
            ;;
        wasm__tools__help__metadata__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
            ;;
        wasm__tools__help__metadata__show)
            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
            ;;
        wasm__tools__help__mutate)
            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
            ;;
        wasm__tools__help__objdump)
            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
            ;;
        wasm__tools__help__parse)
            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
            ;;
        wasm__tools__help__print)
            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
            ;;
        wasm__tools__help__shrink)
            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
            ;;
        wasm__tools__help__smith)
            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
            ;;
        wasm__tools__help__strip)
            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
            ;;
        wasm__tools__help__validate)
            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
            ;;
        wasm__tools__help__wast)
            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
            ;;
        wasm__tools__help__wit__dylib)
            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
            ;;
        wasm__tools__help__wit__smith)
            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
            ;;
        wasm__tools__json__from__wast)
            opts="-v -o -h --verbose --color --output --wasm-dir --pretty --allow-confusing-unicode --help <WAST>"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --wasm-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --allow-confusing-unicode)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__metadata)
            opts="-h --help show add 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
            ;;
        wasm__tools__metadata__add)
            opts="-g -o -v -t -h --generate-dwarf --output --verbose --color --name --clear-name --language --processed-by --sdk --authors --clear-authors --description --clear-description --licenses --clear-licenses --source --clear-source --homepage --clear-homepage --revision --clear-revision --version --clear-version --wat --help [INPUT]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --generate-dwarf)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --name)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --language)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --processed-by)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --sdk)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --authors)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --description)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --licenses)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --source)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --homepage)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --revision)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --version)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__metadata__help)
            opts="show add 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
            ;;
        wasm__tools__metadata__help__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
            ;;
        wasm__tools__metadata__help__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
            ;;
        wasm__tools__metadata__help__show)
            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
            ;;
        wasm__tools__metadata__show)
            opts="-o -v -h --output --verbose --color --json --help [INPUT]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 3 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__mutate)
            opts="-o -v -t -s -f -h --output --verbose --color --wat --seed --preserve-semantics --fuel --reduce --help [INPUT]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --seed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --fuel)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__objdump)
            opts="-o -v -h --output --verbose --color --help [INPUT]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__parse)
            opts="-g -o -v -t -h --generate-dwarf --output --verbose --color --wat --help [INPUT]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --generate-dwarf)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__print)
            opts="-g -o -v -p -f -h --generate-dwarf --output --verbose --color --print-offsets --skeleton --name-unnamed --fold-instructions --print-operand-stack --indent-text --indent --help [INPUT]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --generate-dwarf)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --indent-text)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --indent)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__shrink)
            opts="-a -s -o -v -h --attempts --allow-empty --seed --output --verbose --color --help <PREDICATE> [INPUT]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --attempts)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -a)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --seed)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__smith)
            opts="-o -t -f -c -v -h --output --wat --ensure-termination --fuel --config --available-imports --exports --module-shape --allow-start-export --allowed-instructions --allow-floats --bulk-memory-enabled --canonicalize-nans --disallow-traps --exceptions-enabled --export-everything --gc-enabled --custom-descriptors-enabled --custom-page-sizes-enabled --generate-custom-sections --max-aliases --max-components --max-data-segments --max-element-segments --max-elements --max-exports --max-funcs --max-globals --max-imports --max-instances --max-instructions --max-memories --max-memory32-bytes --max-memory64-bytes --max-modules --max-nesting-depth --max-table-elements --max-tables --max-tags --max-type-size --max-types --max-values --memory64-enabled --memory-max-size-required --memory-offset-choices --min-data-segments --min-element-segments --min-elements --min-exports --min-funcs --min-globals --min-imports --min-memories --min-tables --min-tags --min-types --min-uleb-size --multi-value-enabled --reference-types-enabled --relaxed-simd-enabled --saturating-float-to-int-enabled --sign-extension-ops-enabled --shared-everything-threads-enabled --simd-enabled --tail-call-enabled --table-max-size-required --threads-enabled --allow-invalid-funcs --wide-arithmetic-enabled --extended-const-enabled --const-expr-fuel --limit-arrays-in-const-exprs --verbose --color --help [INPUT]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --fuel)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --config)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --available-imports)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --exports)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --module-shape)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --allow-start-export)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --allowed-instructions)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --allow-floats)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --bulk-memory-enabled)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --canonicalize-nans)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --disallow-traps)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --exceptions-enabled)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --export-everything)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --gc-enabled)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --custom-descriptors-enabled)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --custom-page-sizes-enabled)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --generate-custom-sections)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --max-aliases)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-components)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-data-segments)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-element-segments)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-elements)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-exports)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-funcs)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-globals)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-imports)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-instances)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-instructions)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-memories)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-memory32-bytes)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-memory64-bytes)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-modules)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-nesting-depth)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-table-elements)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-tables)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-type-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-types)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-values)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --memory64-enabled)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --memory-max-size-required)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --memory-offset-choices)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --min-data-segments)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --min-element-segments)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --min-elements)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --min-exports)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --min-funcs)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --min-globals)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --min-imports)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --min-memories)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --min-tables)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --min-tags)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --min-types)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --min-uleb-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --multi-value-enabled)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --reference-types-enabled)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --relaxed-simd-enabled)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --saturating-float-to-int-enabled)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --sign-extension-ops-enabled)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --shared-everything-threads-enabled)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --simd-enabled)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --tail-call-enabled)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --table-max-size-required)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --threads-enabled)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --allow-invalid-funcs)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --wide-arithmetic-enabled)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --extended-const-enabled)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --const-expr-fuel)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --limit-arrays-in-const-exprs)
                    COMPREPLY=($(compgen -W "true false" -- "${cur}"))
                    return 0
                    ;;
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__strip)
            opts="-o -v -a -d -t -h --output --verbose --color --all --delete --wat --help [INPUT]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --delete)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -d)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__validate)
            opts="-g -f -v -h --generate-dwarf --features --verbose --color --help [INPUT]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --generate-dwarf)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --features)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__wast)
            opts="-v -f -a -h --verbose --color --ignore-error-messages --features --allow-confusing-unicode --assert --snapshot --help [INPUT]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --features)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -f)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --assert)
                    COMPREPLY=($(compgen -W "default pretty-whitespace snapshot-print snapshot-json snapshot-folded test-folded no-test-folded permissive" -- "${cur}"))
                    return 0
                    ;;
                -a)
                    COMPREPLY=($(compgen -W "default pretty-whitespace snapshot-print snapshot-json snapshot-folded test-folded no-test-folded permissive" -- "${cur}"))
                    return 0
                    ;;
                --snapshot)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__wit__dylib)
            opts="-o -v -w -t -h --features --all-features --output --verbose --color --encoding --world --validate --wat --interpreter --async --help <WIT> [INPUT]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --features)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --color)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --encoding)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --world)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --interpreter)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --async)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        wasm__tools__wit__smith)
            opts="-o -t -v -h --output --wat --max-packages --max-type-size --max-interface-items --max-world-items --max-pkg-items --max-type-parts --max-files-per-package --max-resource-items --async --futures --streams --error-context --fixed-length-lists --world-include --implements --arbitrary-config --verbose --color --help [INPUT]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --output)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-packages)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-type-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-interface-items)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-world-items)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-pkg-items)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-type-parts)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-files-per-package)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-resource-items)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --color)
                    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 _wasm-tools -o nosort -o bashdefault -o default wasm-tools
else
    complete -F _wasm-tools -o bashdefault -o default wasm-tools
fi
