_task-maker-tools() {
    local i cur prev opts cmd
    COMPREPLY=()
    cur="${COMP_WORDS[COMP_CWORD]}"
    prev="${COMP_WORDS[COMP_CWORD-1]}"
    cmd=""
    opts=""

    for i in ${COMP_WORDS[@]}
    do
        case "${cmd},${i}" in
            ",$1")
                cmd="task__maker__tools"
                ;;
            task__maker__tools,add-solution-checks)
                cmd="task__maker__tools__add__solution__checks"
                ;;
            task__maker__tools,booklet)
                cmd="task__maker__tools__booklet"
                ;;
            task__maker__tools,clear)
                cmd="task__maker__tools__clear"
                ;;
            task__maker__tools,copy-competition-files)
                cmd="task__maker__tools__copy__competition__files"
                ;;
            task__maker__tools,export-booklet)
                cmd="task__maker__tools__export__booklet"
                ;;
            task__maker__tools,export-solution-checks)
                cmd="task__maker__tools__export__solution__checks"
                ;;
            task__maker__tools,find-bad-case)
                cmd="task__maker__tools__find__bad__case"
                ;;
            task__maker__tools,fuzz-checker)
                cmd="task__maker__tools__fuzz__checker"
                ;;
            task__maker__tools,gen-autocompletion)
                cmd="task__maker__tools__gen__autocompletion"
                ;;
            task__maker__tools,help)
                cmd="task__maker__tools__help"
                ;;
            task__maker__tools,internal-sandbox)
                cmd="task__maker__tools__internal__sandbox"
                ;;
            task__maker__tools,reset)
                cmd="task__maker__tools__reset"
                ;;
            task__maker__tools,sandbox)
                cmd="task__maker__tools__sandbox"
                ;;
            task__maker__tools,server)
                cmd="task__maker__tools__server"
                ;;
            task__maker__tools,task-info)
                cmd="task__maker__tools__task__info"
                ;;
            task__maker__tools,terry-statement)
                cmd="task__maker__tools__terry__statement"
                ;;
            task__maker__tools,worker)
                cmd="task__maker__tools__worker"
                ;;
            task__maker__tools__help,add-solution-checks)
                cmd="task__maker__tools__help__add__solution__checks"
                ;;
            task__maker__tools__help,booklet)
                cmd="task__maker__tools__help__booklet"
                ;;
            task__maker__tools__help,clear)
                cmd="task__maker__tools__help__clear"
                ;;
            task__maker__tools__help,copy-competition-files)
                cmd="task__maker__tools__help__copy__competition__files"
                ;;
            task__maker__tools__help,export-booklet)
                cmd="task__maker__tools__help__export__booklet"
                ;;
            task__maker__tools__help,export-solution-checks)
                cmd="task__maker__tools__help__export__solution__checks"
                ;;
            task__maker__tools__help,find-bad-case)
                cmd="task__maker__tools__help__find__bad__case"
                ;;
            task__maker__tools__help,fuzz-checker)
                cmd="task__maker__tools__help__fuzz__checker"
                ;;
            task__maker__tools__help,gen-autocompletion)
                cmd="task__maker__tools__help__gen__autocompletion"
                ;;
            task__maker__tools__help,help)
                cmd="task__maker__tools__help__help"
                ;;
            task__maker__tools__help,internal-sandbox)
                cmd="task__maker__tools__help__internal__sandbox"
                ;;
            task__maker__tools__help,reset)
                cmd="task__maker__tools__help__reset"
                ;;
            task__maker__tools__help,sandbox)
                cmd="task__maker__tools__help__sandbox"
                ;;
            task__maker__tools__help,server)
                cmd="task__maker__tools__help__server"
                ;;
            task__maker__tools__help,task-info)
                cmd="task__maker__tools__help__task__info"
                ;;
            task__maker__tools__help,terry-statement)
                cmd="task__maker__tools__help__terry__statement"
                ;;
            task__maker__tools__help,worker)
                cmd="task__maker__tools__help__worker"
                ;;
            *)
                ;;
        esac
    done

    case "${cmd}" in
        task__maker__tools)
            opts="-v -h --verbose --help clear gen-autocompletion server worker reset sandbox task-info booklet copy-competition-files terry-statement fuzz-checker find-bad-case add-solution-checks export-solution-checks export-booklet internal-sandbox 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
            ;;
        task__maker__tools__add__solution__checks)
            opts="-t -s -i -o -h --task-dir --max-depth --ui --store-dir --max-cache --min-cache --solution --keep-sandboxes --dry-run --no-cache --extra-time --extra-memory --copy-exe --copy-logs --copy-dag --num-cores --evaluate-on --name --priority --in-place --overwrite --help [FILTER]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --task-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-depth)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --ui)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --store-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-cache)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --min-cache)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --solution)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --no-cache)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --extra-time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --extra-memory)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --num-cores)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --evaluate-on)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --name)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --priority)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        task__maker__tools__booklet)
            opts="-c -t -h --booklet-solutions --contest-dir --task-dir --max-depth --ui --keep-sandboxes --dry-run --no-cache --extra-time --extra-memory --copy-exe --copy-logs --copy-dag --num-cores --evaluate-on --name --priority --store-dir --max-cache --min-cache --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --contest-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --task-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-depth)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --ui)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --no-cache)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --extra-time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --extra-memory)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --num-cores)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --evaluate-on)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --name)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --priority)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --store-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-cache)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --min-cache)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        task__maker__tools__clear)
            opts="-t -h --task-dir --max-depth --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --task-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-depth)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        task__maker__tools__copy__competition__files)
            opts="-c -h --contest-dir --ui --keep-sandboxes --dry-run --no-cache --extra-time --extra-memory --copy-exe --copy-logs --copy-dag --num-cores --evaluate-on --name --priority --store-dir --max-cache --min-cache --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --contest-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --ui)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --no-cache)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --extra-time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --extra-memory)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --num-cores)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --evaluate-on)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --name)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --priority)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --store-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-cache)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --min-cache)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        task__maker__tools__export__booklet)
            opts="-c -t -h --booklet-solutions --contest-dir --task-dir --max-depth --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --contest-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -c)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --task-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-depth)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        task__maker__tools__export__solution__checks)
            opts="-t -s -h --task-dir --max-depth --solution --help [FILTER]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --task-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-depth)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --solution)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        task__maker__tools__find__bad__case)
            opts="-t -b -h --task-dir --max-depth --keep-sandboxes --dry-run --no-cache --extra-time --extra-memory --copy-exe --copy-logs --copy-dag --num-cores --evaluate-on --name --priority --store-dir --max-cache --min-cache --batch-size --help <SOLUTION> [GENERATOR_ARGS]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --task-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-depth)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --no-cache)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --extra-time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --extra-memory)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --num-cores)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --evaluate-on)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --name)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --priority)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --store-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-cache)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --min-cache)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --batch-size)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -b)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        task__maker__tools__fuzz__checker)
            opts="-t -j -h --task-dir --max-depth --fuzz-dir --sanitizers --jobs --checker-timeout --max-time --quiet --no-build --keep-sandboxes --dry-run --no-cache --extra-time --extra-memory --copy-exe --copy-logs --copy-dag --num-cores --evaluate-on --name --priority --store-dir --max-cache --min-cache --help [EXTRA_ARGS]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --task-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-depth)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --fuzz-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --sanitizers)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --jobs)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -j)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --checker-timeout)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --no-cache)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --extra-time)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --extra-memory)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --num-cores)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --evaluate-on)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --name)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --priority)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --store-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-cache)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --min-cache)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        task__maker__tools__gen__autocompletion)
            opts="-t -h --target --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --target)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        task__maker__tools__help)
            opts="clear gen-autocompletion server worker reset sandbox task-info booklet copy-competition-files terry-statement fuzz-checker find-bad-case add-solution-checks export-solution-checks export-booklet internal-sandbox 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
            ;;
        task__maker__tools__help__add__solution__checks)
            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
            ;;
        task__maker__tools__help__booklet)
            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
            ;;
        task__maker__tools__help__clear)
            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
            ;;
        task__maker__tools__help__copy__competition__files)
            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
            ;;
        task__maker__tools__help__export__booklet)
            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
            ;;
        task__maker__tools__help__export__solution__checks)
            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
            ;;
        task__maker__tools__help__find__bad__case)
            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
            ;;
        task__maker__tools__help__fuzz__checker)
            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
            ;;
        task__maker__tools__help__gen__autocompletion)
            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
            ;;
        task__maker__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
            ;;
        task__maker__tools__help__internal__sandbox)
            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
            ;;
        task__maker__tools__help__reset)
            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
            ;;
        task__maker__tools__help__sandbox)
            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
            ;;
        task__maker__tools__help__server)
            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
            ;;
        task__maker__tools__help__task__info)
            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
            ;;
        task__maker__tools__help__terry__statement)
            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
            ;;
        task__maker__tools__help__worker)
            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
            ;;
        task__maker__tools__internal__sandbox)
            opts="-h --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
            ;;
        task__maker__tools__reset)
            opts="-h --store-dir --max-cache --min-cache --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --store-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-cache)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --min-cache)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        task__maker__tools__sandbox)
            opts="-w -m -s -r -h --workdir --memory-limit --stack-limit --single-process --readable-dirs --mount-tmpfs --mount-proc --uid --gid --help [COMMAND]..."
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --workdir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -w)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --memory-limit)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -m)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --stack-limit)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --readable-dirs)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -r)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --uid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --gid)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        task__maker__tools__server)
            opts="-h --client-password --worker-password --store-dir --max-cache --min-cache --help [CLIENT_ADDR] [WORKER_ADDR]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --client-password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --worker-password)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --store-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-cache)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --min-cache)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        task__maker__tools__task__info)
            opts="-t -j -h --task-dir --max-depth --json --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --task-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-depth)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        task__maker__tools__terry__statement)
            opts="-s -t -o -h --statement-path --subtasks-path --output-path --max-depth --help"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --statement-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -s)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --subtasks-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -t)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --output-path)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                -o)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-depth)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                *)
                    COMPREPLY=()
                    ;;
            esac
            COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
            return 0
            ;;
        task__maker__tools__worker)
            opts="-h --name --store-dir --max-cache --min-cache --help <SERVER_ADDR> [WORKER_ID]"
            if [[ ${cur} == -* || ${COMP_CWORD} -eq 2 ]] ; then
                COMPREPLY=( $(compgen -W "${opts}" -- "${cur}") )
                return 0
            fi
            case "${prev}" in
                --name)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --store-dir)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --max-cache)
                    COMPREPLY=($(compgen -f "${cur}"))
                    return 0
                    ;;
                --min-cache)
                    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 _task-maker-tools -o nosort -o bashdefault -o default task-maker-tools
else
    complete -F _task-maker-tools -o bashdefault -o default task-maker-tools
fi
